xcelerate 0.1.3

// <auto-generated>
//     This file was generated by uniffi-bindgen-cs v0.10.0+v0.29.4
//     See https://github.com/NordSecurity/uniffi-bindgen-cs for more information.
// </auto-generated>

#nullable enable





using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
namespace uniffi.xcelerate_core;



// This is a helper for safely working with byte buffers returned from the Rust code.
// A rust-owned buffer is represented by its capacity, its current length, and a
// pointer to the underlying data.

[StructLayout(LayoutKind.Sequential)]
public struct RustBuffer {
    public ulong capacity;
    public ulong len;
    public IntPtr data;

    public static RustBuffer Alloc(int size) {
        return _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            var buffer = _UniFFILib.ffi_xcelerate_core_rustbuffer_alloc(Convert.ToUInt64(size), ref status);
            if (buffer.data == IntPtr.Zero) {
                throw new AllocationException($"RustBuffer.Alloc() returned null data pointer (size={size})");
            }
            return buffer;
        });
    }

    public static void Free(RustBuffer buffer) {
        _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            _UniFFILib.ffi_xcelerate_core_rustbuffer_free(buffer, ref status);
        });
    }

    public static BigEndianStream MemoryStream(IntPtr data, long length)
    {
        unsafe
        {
            return new BigEndianStream(new UnmanagedMemoryStream((byte*)data.ToPointer(), length));
        }
    }

    public BigEndianStream AsStream()
    {
        unsafe
        {
            return new BigEndianStream(
                new UnmanagedMemoryStream((byte*)data.ToPointer(), Convert.ToInt64(len))
            );
        }
    }

    public BigEndianStream AsWriteableStream()
    {
        unsafe
        {
            return new BigEndianStream(
                new UnmanagedMemoryStream(
                    (byte*)data.ToPointer(),
                    Convert.ToInt64(capacity),
                    Convert.ToInt64(capacity),
                    FileAccess.Write
                )
            );
        }
    }
}

// This is a helper for safely passing byte references into the rust code.
// It's not actually used at the moment, because there aren't many things that you
// can take a direct pointer to managed memory, and if we're going to copy something
// then we might as well copy it into a `RustBuffer`. But it's here for API
// completeness.

[StructLayout(LayoutKind.Sequential)]
public struct ForeignBytes {
    public int length;
    public IntPtr data;
}


// The FfiConverter interface handles converter types to and from the FFI
//
// All implementing objects should be public to support external types.  When a
// type is external we need to import it's FfiConverter.
public abstract class FfiConverter<CsType, FfiType> {
    // Convert an FFI type to a C# type
    public abstract CsType Lift(FfiType value);

    // Convert C# type to an FFI type
    public abstract FfiType Lower(CsType value);

    // Read a C# type from a `ByteBuffer`
    public abstract CsType Read(BigEndianStream stream);

    // Calculate bytes to allocate when creating a `RustBuffer`
    //
    // This must return at least as many bytes as the write() function will
    // write. It can return more bytes than needed, for example when writing
    // Strings we can't know the exact bytes needed until we the UTF-8
    // encoding, so we pessimistically allocate the largest size possible (3
    // bytes per codepoint).  Allocating extra bytes is not really a big deal
    // because the `RustBuffer` is short-lived.
    public abstract int AllocationSize(CsType value);

    // Write a C# type to a `ByteBuffer`
    public abstract void Write(CsType value, BigEndianStream stream);

    // Lower a value into a `RustBuffer`
    //
    // This method lowers a value into a `RustBuffer` rather than the normal
    // FfiType.  It's used by the callback interface code.  Callback interface
    // returns are always serialized into a `RustBuffer` regardless of their
    // normal FFI type.
    public RustBuffer LowerIntoRustBuffer(CsType value) {
        var rbuf = RustBuffer.Alloc(AllocationSize(value));
        try {
            var stream = rbuf.AsWriteableStream();
            Write(value, stream);
            rbuf.len = Convert.ToUInt64(stream.Position);
            return rbuf;
        } catch {
            RustBuffer.Free(rbuf);
            throw;
        }
    }

    // Lift a value from a `RustBuffer`.
    //
    // This here mostly because of the symmetry with `lowerIntoRustBuffer()`.
    // It's currently only used by the `FfiConverterRustBuffer` class below.
    protected CsType LiftFromRustBuffer(RustBuffer rbuf) {
        var stream = rbuf.AsStream();
        try {
           var item = Read(stream);
           if (stream.HasRemaining()) {
               throw new InternalException("junk remaining in buffer after lifting, something is very wrong!!");
           }
           return item;
        } finally {
            RustBuffer.Free(rbuf);
        }
    }
}

// FfiConverter that uses `RustBuffer` as the FfiType
public abstract class FfiConverterRustBuffer<CsType>: FfiConverter<CsType, RustBuffer> {
    public override CsType Lift(RustBuffer value) {
        return LiftFromRustBuffer(value);
    }
    public override RustBuffer Lower(CsType value) {
        return LowerIntoRustBuffer(value);
    }
}


// A handful of classes and functions to support the generated data structures.
// This would be a good candidate for isolating in its own ffi-support lib.
// Error runtime.
[StructLayout(LayoutKind.Sequential)]
public struct UniffiRustCallStatus {
    public sbyte code;
    public RustBuffer error_buf;

    public bool IsSuccess() {
        return code == 0;
    }

    public bool IsError() {
        return code == 1;
    }

    public bool IsPanic() {
        return code == 2;
    }
}

// Base class for all uniffi exceptions
public class UniffiException: System.Exception {
    public UniffiException(): base() {}
    public UniffiException(string message): base(message) {}
}

public class UndeclaredErrorException: UniffiException {
    public UndeclaredErrorException(string message): base(message) {}
}

public class PanicException: UniffiException {
    public PanicException(string message): base(message) {}
}

public class AllocationException: UniffiException {
    public AllocationException(string message): base(message) {}
}

public class InternalException: UniffiException {
    public InternalException(string message): base(message) {}
}

public class InvalidEnumException: InternalException {
    public InvalidEnumException(string message): base(message) {
    }
}

public class UniffiContractVersionException: UniffiException {
    public UniffiContractVersionException(string message): base(message) {
    }
}

public class UniffiContractChecksumException: UniffiException {
    public UniffiContractChecksumException(string message): base(message) {
    }
}

// Each top-level error class has a companion object that can lift the error from the call status's rust buffer
public interface CallStatusErrorHandler<E> where E: System.Exception {
    E Lift(RustBuffer error_buf);
}

// CallStatusErrorHandler implementation for times when we don't expect a CALL_ERROR
public class NullCallStatusErrorHandler: CallStatusErrorHandler<UniffiException> {
    public static NullCallStatusErrorHandler INSTANCE = new NullCallStatusErrorHandler();

    public UniffiException Lift(RustBuffer error_buf) {
        RustBuffer.Free(error_buf);
        return new UndeclaredErrorException("library has returned an error not declared in UNIFFI interface file");
    }
}

// Helpers for calling Rust
// In practice we usually need to be synchronized to call this safely, so it doesn't
// synchronize itself
public class _UniffiHelpers {
    public delegate void RustCallAction(ref UniffiRustCallStatus status);
    public delegate U RustCallFunc<out U>(ref UniffiRustCallStatus status);

    // Call a rust function that returns a Result<>.  Pass in the Error class companion that corresponds to the Err
    public static U RustCallWithError<U, E>(CallStatusErrorHandler<E> errorHandler, RustCallFunc<U> callback)
        where E: UniffiException
    {
        var status = new UniffiRustCallStatus();
        var return_value = callback(ref status);
        if (status.IsSuccess()) {
            return return_value;
        } else if (status.IsError()) {
            throw errorHandler.Lift(status.error_buf);
        } else if (status.IsPanic()) {
            // when the rust code sees a panic, it tries to construct a rustbuffer
            // with the message.  but if that code panics, then it just sends back
            // an empty buffer.
            if (status.error_buf.len > 0) {
                throw new PanicException(FfiConverterString.INSTANCE.Lift(status.error_buf));
            } else {
                throw new PanicException("Rust panic");
            }
        } else {
            throw new InternalException($"Unknown rust call status: {status.code}");
        }
    }

    // Call a rust function that returns a Result<>.  Pass in the Error class companion that corresponds to the Err
    public static void RustCallWithError<E>(CallStatusErrorHandler<E> errorHandler, RustCallAction callback)
        where E: UniffiException
    {
        _UniffiHelpers.RustCallWithError(errorHandler, (ref UniffiRustCallStatus status) => {
            callback(ref status);
            return 0;
        });
    }

    // Call a rust function that returns a plain value
    public static U RustCall<U>(RustCallFunc<U> callback) {
        return _UniffiHelpers.RustCallWithError(NullCallStatusErrorHandler.INSTANCE, callback);
    }

    // Call a rust function that returns a plain value
    public static void RustCall(RustCallAction callback) {
        _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            callback(ref status);
            return 0;
        });
    }
}

static class FFIObjectUtil {
    public static void DisposeAll(params Object?[] list) {
        Dispose(list);
    }

    // Dispose is implemented by recursive type inspection at runtime. This is because
    // generating correct Dispose calls for recursive complex types, e.g. List<List<int>>
    // is quite cumbersome.
   private static void Dispose(Object? obj) {
         if (obj == null) {
             return;
         }

         if (obj is IDisposable disposable) {
             disposable.Dispose();
             return;
         }

         var objType = obj.GetType();
         var typeCode = Type.GetTypeCode(objType);
         if (typeCode != TypeCode.Object) {
             return;
         }

         var genericArguments = objType.GetGenericArguments();
         if (genericArguments.Length == 0 && !objType.IsArray) {
             return;
         }

         if (obj is System.Collections.IDictionary objDictionary) {
             //This extra code tests to not call "Dispose" for a Dictionary<something, double>()
             //for all values as "double" and alike doesn't support interface "IDisposable"
             var valuesType = objType.GetGenericArguments()[1];
             var elementValuesTypeCode = Type.GetTypeCode(valuesType);
             if (elementValuesTypeCode != TypeCode.Object) {
                 return;
             }
             foreach (var value in objDictionary.Values) {
                 Dispose(value);
             }
         }
         else if (obj is System.Collections.IEnumerable listValues) {
             //This extra code tests to not call "Dispose" for a List<int>()
             //for all keys as "int" and alike doesn't support interface "IDisposable"
             var elementType = objType.IsArray ? objType.GetElementType() : genericArguments[0];
             var elementValuesTypeCode = Type.GetTypeCode(elementType);
             if (elementValuesTypeCode != TypeCode.Object) {
                 return;
             }
             foreach (var value in listValues) {
                 Dispose(value);
             }
         }
     }
}


// Big endian streams are not yet available in dotnet :'(
// https://github.com/dotnet/runtime/issues/26904

public class StreamUnderflowException: System.Exception {
    public StreamUnderflowException() {
    }
}

static class BigEndianStreamExtensions
{
    public static void WriteInt32(this Stream stream, int value, int bytesToWrite = 4)
    {
#if DOTNET_8_0_OR_GREATER

        Span<byte> buffer = stackalloc byte[bytesToWrite];
#else

        byte[] buffer = new byte[bytesToWrite];
#endif

        var posByte = bytesToWrite;
        while (posByte != 0)
        {
            posByte--;
            buffer[posByte] = (byte)(value);
            value >>= 8;
        }

#if DOTNET_8_0_OR_GREATER

        stream.Write(buffer);
#else

        stream.Write(buffer, 0, buffer.Length);
#endif

    }

    public static void WriteInt64(this Stream stream, long value)
    {
        int bytesToWrite = 8;
#if DOTNET_8_0_OR_GREATER

         Span<byte> buffer = stackalloc byte[bytesToWrite];
 #else

         byte[] buffer = new byte[bytesToWrite];
 #endif

        var posByte = bytesToWrite;
        while (posByte != 0)
        {
            posByte--;
            buffer[posByte] = (byte)(value);
            value >>= 8;
        }

#if DOTNET_8_0_OR_GREATER

        stream.Write(buffer);
#else

        stream.Write(buffer, 0, buffer.Length);
#endif

    }

    public static uint ReadUint32(this Stream stream, int bytesToRead = 4) {
        CheckRemaining(stream, bytesToRead);
#if DOTNET_8_0_OR_GREATER

         Span<byte> buffer = stackalloc byte[bytesToRead];
         stream.Read(buffer);
#else

        byte[] buffer = new byte[bytesToRead];
        stream.Read(buffer, 0, bytesToRead);
#endif

        uint result = 0;
        uint digitMultiplier = 1;
        int posByte = bytesToRead;
        while (posByte != 0)
        {
            posByte--;
            result |= buffer[posByte]*digitMultiplier;
            digitMultiplier <<= 8;
        }

        return result;
    }

    public static ulong ReadUInt64(this Stream stream) {
        int bytesToRead = 8;
        CheckRemaining(stream, bytesToRead);
#if DOTNET_8_0_OR_GREATER

         Span<byte> buffer = stackalloc byte[bytesToRead];
         stream.Read(buffer);
#else

        byte[] buffer = new byte[bytesToRead];
        stream.Read(buffer, 0, bytesToRead);
#endif

        ulong result = 0;
        ulong digitMultiplier = 1;
        int posByte = bytesToRead;
        while (posByte != 0)
        {
            posByte--;
            result |= buffer[posByte]*digitMultiplier;
            digitMultiplier <<= 8;
        }

        return result;
    }

    public static void CheckRemaining(this Stream stream, int length) {
        if (stream.Length - stream.Position < length) {
            throw new StreamUnderflowException();
        }
    }

    public static void ForEach<T>(this T[] items, Action<T> action){
        foreach (var item in items) {
            action(item);
        }
    }
}

public class BigEndianStream {
    Stream stream;
    public BigEndianStream(Stream stream) {
        this.stream = stream;
    }

    public bool HasRemaining() {
        return (stream.Length - Position) > 0;
    }

    public long Position {
        get => stream.Position;
        set => stream.Position = value;
    }

    public void WriteBytes(byte[] buffer) {
#if DOTNET_8_0_OR_GREATER

        stream.Write(buffer);
#else

        stream.Write(buffer, 0, buffer.Length);
#endif

    }

    public void WriteByte(byte value) => stream.WriteInt32(value, bytesToWrite: 1);
    public void WriteSByte(sbyte value) => stream.WriteInt32(value, bytesToWrite: 1);

    public void WriteUShort(ushort value) => stream.WriteInt32(value, bytesToWrite: 2);
    public void WriteShort(short value) => stream.WriteInt32(value, bytesToWrite: 2);

    public void WriteUInt(uint value) => stream.WriteInt32((int)value);
    public void WriteInt(int value) => stream.WriteInt32(value);

    public void WriteULong(ulong value) => stream.WriteInt64((long)value);
    public void WriteLong(long value) => stream.WriteInt64(value);

    public void WriteFloat(float value) {
        unsafe {
            WriteInt(*((int*)&value));
        }
    }
    public void WriteDouble(double value) => stream.WriteInt64(BitConverter.DoubleToInt64Bits(value));

    public byte[] ReadBytes(int length) {
        stream.CheckRemaining(length);
        byte[] result = new byte[length];
        stream.Read(result, 0, length);
        return result;
    }

    public byte ReadByte() => (byte)stream.ReadUint32(bytesToRead: 1);
    public ushort ReadUShort() => (ushort)stream.ReadUint32(bytesToRead: 2);
    public uint ReadUInt() => (uint)stream.ReadUint32(bytesToRead: 4);
    public ulong ReadULong() => stream.ReadUInt64();

    public sbyte ReadSByte() => (sbyte)ReadByte();
    public short ReadShort() => (short)ReadUShort();
    public int ReadInt() => (int)ReadUInt();

    public float ReadFloat() {
        unsafe {
            int value = ReadInt();
            return *((float*)&value);
        }
    }

    public long ReadLong() => (long)ReadULong();
    public double ReadDouble() => BitConverter.Int64BitsToDouble(ReadLong());
}

// Contains loading, initialization code,
// and the FFI Function declarations in a com.sun.jna.Library.


// This is an implementation detail that will be called internally by the public API.
static class _UniFFILib {
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiRustFutureContinuationCallback(
        ulong @data,sbyte @pollResult
    );
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureFree(
        ulong @handle
    );
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiCallbackInterfaceFree(
        ulong @handle
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFuture
    {
        public ulong @handle;
        public IntPtr @free;
    }
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructU8
    {
        public byte @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteU8(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructU8 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructI8
    {
        public sbyte @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteI8(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructI8 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructU16
    {
        public ushort @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteU16(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructU16 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructI16
    {
        public short @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteI16(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructI16 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructU32
    {
        public uint @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteU32(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructU32 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructI32
    {
        public int @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteI32(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructI32 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructU64
    {
        public ulong @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteU64(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructU64 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructI64
    {
        public long @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteI64(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructI64 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructF32
    {
        public float @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteF32(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructF32 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructF64
    {
        public double @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteF64(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructF64 @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructPointer
    {
        public IntPtr @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompletePointer(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructPointer @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructRustBuffer
    {
        public RustBuffer @returnValue;
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteRustBuffer(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructRustBuffer @result
    );
    [StructLayout(LayoutKind.Sequential)]
    public struct UniffiForeignFutureStructVoid
    {
        public UniffiRustCallStatus @callStatus;
    }
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void UniffiForeignFutureCompleteVoid(
        ulong @callbackData,_UniFFILib.UniffiForeignFutureStructVoid @result
    );
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    static _UniFFILib() {
        _UniFFILib.uniffiCheckContractApiVersion();
        _UniFFILib.uniffiCheckApiChecksums();
        
        }

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_clone_browser(IntPtr @ptr,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void uniffi_xcelerate_core_fn_free_browser(IntPtr @ptr,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_constructor_browser_launch(RustBuffer @config
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_browser_close(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_browser_new_page(IntPtr @ptr,RustBuffer @url
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_browser_version(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_clone_element(IntPtr @ptr,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void uniffi_xcelerate_core_fn_free_element(IntPtr @ptr,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_element_attribute(IntPtr @ptr,RustBuffer @name
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_element_click(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_element_focus(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_element_hover(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_element_inner_html(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_element_text(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_element_type_text(IntPtr @ptr,RustBuffer @text
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_clone_page(IntPtr @ptr,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void uniffi_xcelerate_core_fn_free_page(IntPtr @ptr,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_add_script_to_evaluate_on_new_document(IntPtr @ptr,RustBuffer @source
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_content(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_find_element(IntPtr @ptr,RustBuffer @selector
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_go_back(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_navigate(IntPtr @ptr,RustBuffer @url
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_pdf(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_reload(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_screenshot(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_screenshot_full(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_title(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_wait_for_navigation(IntPtr @ptr
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr uniffi_xcelerate_core_fn_method_page_wait_for_selector(IntPtr @ptr,RustBuffer @selector
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern RustBuffer ffi_xcelerate_core_rustbuffer_alloc(ulong @size,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern RustBuffer ffi_xcelerate_core_rustbuffer_from_bytes(ForeignBytes @bytes,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rustbuffer_free(RustBuffer @buf,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern RustBuffer ffi_xcelerate_core_rustbuffer_reserve(RustBuffer @buf,ulong @additional,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_u8(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_u8(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_u8(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern byte ffi_xcelerate_core_rust_future_complete_u8(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_i8(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_i8(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_i8(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern sbyte ffi_xcelerate_core_rust_future_complete_i8(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_u16(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_u16(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_u16(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort ffi_xcelerate_core_rust_future_complete_u16(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_i16(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_i16(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_i16(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern short ffi_xcelerate_core_rust_future_complete_i16(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_u32(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_u32(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_u32(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern uint ffi_xcelerate_core_rust_future_complete_u32(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_i32(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_i32(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_i32(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern int ffi_xcelerate_core_rust_future_complete_i32(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_u64(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_u64(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_u64(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ulong ffi_xcelerate_core_rust_future_complete_u64(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_i64(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_i64(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_i64(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern long ffi_xcelerate_core_rust_future_complete_i64(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_f32(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_f32(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_f32(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern float ffi_xcelerate_core_rust_future_complete_f32(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_f64(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_f64(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_f64(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern double ffi_xcelerate_core_rust_future_complete_f64(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_pointer(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_pointer(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_pointer(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr ffi_xcelerate_core_rust_future_complete_pointer(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_rust_buffer(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_rust_buffer(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_rust_buffer(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern RustBuffer ffi_xcelerate_core_rust_future_complete_rust_buffer(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_poll_void(IntPtr @handle,IntPtr @callback,IntPtr @callbackData
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_cancel_void(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_free_void(IntPtr @handle
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ffi_xcelerate_core_rust_future_complete_void(IntPtr @handle,ref UniffiRustCallStatus _uniffi_out_err
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_browser_close(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_browser_new_page(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_browser_version(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_element_attribute(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_element_click(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_element_focus(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_element_hover(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_element_inner_html(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_element_text(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_element_type_text(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_add_script_to_evaluate_on_new_document(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_content(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_find_element(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_go_back(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_navigate(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_pdf(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_reload(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_screenshot(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_screenshot_full(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_title(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_wait_for_navigation(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_method_page_wait_for_selector(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern ushort uniffi_xcelerate_core_checksum_constructor_browser_launch(
    );

    [DllImport("xcelerate_core", CallingConvention = CallingConvention.Cdecl)]
    public static extern uint ffi_xcelerate_core_uniffi_contract_version(
    );

    

    static void uniffiCheckContractApiVersion() {
        var scaffolding_contract_version = _UniFFILib.ffi_xcelerate_core_uniffi_contract_version();
        if (29 != scaffolding_contract_version) {
            throw new UniffiContractVersionException($"uniffi.xcelerate_core: uniffi bindings expected version `29`, library returned `{scaffolding_contract_version}`");
        }
    }

    static void uniffiCheckApiChecksums() {
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_browser_close();
            if (checksum != 58870) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_browser_close` checksum `58870`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_browser_new_page();
            if (checksum != 6589) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_browser_new_page` checksum `6589`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_browser_version();
            if (checksum != 25979) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_browser_version` checksum `25979`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_element_attribute();
            if (checksum != 1460) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_element_attribute` checksum `1460`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_element_click();
            if (checksum != 54597) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_element_click` checksum `54597`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_element_focus();
            if (checksum != 12783) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_element_focus` checksum `12783`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_element_hover();
            if (checksum != 38740) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_element_hover` checksum `38740`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_element_inner_html();
            if (checksum != 18173) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_element_inner_html` checksum `18173`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_element_text();
            if (checksum != 47866) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_element_text` checksum `47866`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_element_type_text();
            if (checksum != 14210) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_element_type_text` checksum `14210`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_add_script_to_evaluate_on_new_document();
            if (checksum != 31741) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_add_script_to_evaluate_on_new_document` checksum `31741`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_content();
            if (checksum != 28639) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_content` checksum `28639`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_find_element();
            if (checksum != 19912) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_find_element` checksum `19912`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_go_back();
            if (checksum != 60303) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_go_back` checksum `60303`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_navigate();
            if (checksum != 37964) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_navigate` checksum `37964`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_pdf();
            if (checksum != 37168) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_pdf` checksum `37168`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_reload();
            if (checksum != 10875) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_reload` checksum `10875`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_screenshot();
            if (checksum != 3953) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_screenshot` checksum `3953`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_screenshot_full();
            if (checksum != 25762) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_screenshot_full` checksum `25762`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_title();
            if (checksum != 35947) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_title` checksum `35947`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_wait_for_navigation();
            if (checksum != 49988) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_wait_for_navigation` checksum `49988`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_method_page_wait_for_selector();
            if (checksum != 51060) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_method_page_wait_for_selector` checksum `51060`, library returned `{checksum}`");
            }
        }
        {
            var checksum = _UniFFILib.uniffi_xcelerate_core_checksum_constructor_browser_launch();
            if (checksum != 23267) {
                throw new UniffiContractChecksumException($"uniffi.xcelerate_core: uniffi bindings expected function `uniffi_xcelerate_core_checksum_constructor_browser_launch` checksum `23267`, library returned `{checksum}`");
            }
        }
    }
}

// Public interface members begin here.

#pragma warning disable 8625





public class FfiConverterBoolean: FfiConverter<bool, sbyte> {
    public static FfiConverterBoolean INSTANCE = new FfiConverterBoolean();

    public override bool Lift(sbyte value) {
        return value != 0;
    }

    public override bool Read(BigEndianStream stream) {
        return Lift(stream.ReadSByte());
    }

    public override sbyte Lower(bool value) {
        return value ? (sbyte)1 : (sbyte)0;
    }

    public override int AllocationSize(bool value) {
        return (sbyte)1;
    }

    public override void Write(bool value, BigEndianStream stream) {
        stream.WriteSByte(Lower(value));
    }
}



public class FfiConverterString: FfiConverter<string, RustBuffer> {
    public static FfiConverterString INSTANCE = new FfiConverterString();

    // Note: we don't inherit from FfiConverterRustBuffer, because we use a
    // special encoding when lowering/lifting.  We can use `RustBuffer.len` to
    // store our length and avoid writing it out to the buffer.
    public override string Lift(RustBuffer value) {
        try {
            var bytes = value.AsStream().ReadBytes(Convert.ToInt32(value.len));
            return System.Text.Encoding.UTF8.GetString(bytes);
        } finally {
            RustBuffer.Free(value);
        }
    }

    public override string Read(BigEndianStream stream) {
        var length = stream.ReadInt();
        var bytes = stream.ReadBytes(length);
        return System.Text.Encoding.UTF8.GetString(bytes);
    }

    public override RustBuffer Lower(string value) {
        var bytes = System.Text.Encoding.UTF8.GetBytes(value);
        var rbuf = RustBuffer.Alloc(bytes.Length);
        rbuf.AsWriteableStream().WriteBytes(bytes);
        return rbuf;
    }

    // TODO(CS)
    // We aren't sure exactly how many bytes our string will be once it's UTF-8
    // encoded.  Allocate 3 bytes per unicode codepoint which will always be
    // enough.
    public override int AllocationSize(string value) {
        const int sizeForLength = 4;
        var sizeForString = System.Text.Encoding.UTF8.GetByteCount(value);
        return sizeForLength + sizeForString;
    }

    public override void Write(string value, BigEndianStream stream) {
        var bytes = System.Text.Encoding.UTF8.GetBytes(value);
        stream.WriteInt(bytes.Length);
        stream.WriteBytes(bytes);
    }
}




public class FfiConverterByteArray: FfiConverterRustBuffer<byte[]> {
    public static FfiConverterByteArray INSTANCE = new FfiConverterByteArray();

    public override byte[] Read(BigEndianStream stream) {
        var length = stream.ReadInt();
        return stream.ReadBytes(length);
    }

    public override int AllocationSize(byte[] value) {
        return 4 + value.Length;
    }

    public override void Write(byte[] value, BigEndianStream stream) {
        stream.WriteInt(value.Length);
        stream.WriteBytes(value);
    }
}



/// <summary>
/// Represents a browser instance (e.g., Chrome or Edge).
/// </summary>
public interface IBrowser {
    /// <summary>
    /// Closes the browser and kills the process.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task Close();
    /// <exception cref="XcelerateException"></exception>
    Task<Page> NewPage(string @url);
    /// <summary>
    /// Returns the browser version information.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<string> Version();
}
/// <summary>
/// Represents a browser instance (e.g., Chrome or Edge).
/// </summary>
public class Browser : IBrowser, IDisposable {
    protected IntPtr pointer;
    private int _wasDestroyed = 0;
    private long _callCounter = 1;

    public Browser(IntPtr pointer) {
        this.pointer = pointer;
    }

    ~Browser() {
        Destroy();
    }

    protected void FreeRustArcPtr() {
        _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            _UniFFILib.uniffi_xcelerate_core_fn_free_browser(this.pointer, ref status);
        });
    }

    protected IntPtr CloneRustArcPtr() {
        return _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            return _UniFFILib.uniffi_xcelerate_core_fn_clone_browser(this.pointer, ref status);
        });
    }

    public void Destroy()
    {
        // Only allow a single call to this method.
        if (Interlocked.CompareExchange(ref _wasDestroyed, 1, 0) == 0)
        {
            // This decrement always matches the initial count of 1 given at creation time.
            if (Interlocked.Decrement(ref _callCounter) == 0)
            {
                FreeRustArcPtr();
            }
        }
    }

    public void Dispose()
    {
        Destroy();
        GC.SuppressFinalize(this); // Suppress finalization to avoid unnecessary GC overhead.
    }

    private void IncrementCallCounter() 
    {
        // Check and increment the call counter, to keep the object alive.
        // This needs a compare-and-set retry loop in case of concurrent updates.
        long count;
        do
        {
            count = Interlocked.Read(ref _callCounter);
            if (count == 0L) throw new System.ObjectDisposedException(String.Format("'{0}' object has already been destroyed", this.GetType().Name));
            if (count == long.MaxValue) throw new System.OverflowException(String.Format("'{0}' call counter would overflow", this.GetType().Name));

        } while (Interlocked.CompareExchange(ref _callCounter, count + 1, count) != count);
    }

    private void DecrementCallCounter() 
    {
        // This decrement always matches the increment we performed above.
        if (Interlocked.Decrement(ref _callCounter) == 0) {
            FreeRustArcPtr();
        }
    }

    internal void CallWithPointer(Action<IntPtr> action)
    {
        IncrementCallCounter();
        try {
            action(CloneRustArcPtr());
        }
        finally {
            DecrementCallCounter();
        }
    }

    internal T CallWithPointer<T>(Func<IntPtr, T> func)
    {   
        IncrementCallCounter();
        try {
            return func(CloneRustArcPtr());
        }
        finally {
            DecrementCallCounter();
        }
    }

    
    /// <summary>
    /// Closes the browser and kills the process.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task Close() {await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_browser_close(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_void(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {_UniFFILib.ffi_xcelerate_core_rust_future_complete_void(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_void(future),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <exception cref="XcelerateException"></exception>
    public async Task<Page> NewPage(string @url) {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_browser_new_page(thisPtr, FfiConverterString.INSTANCE.Lower(@url));
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypePage.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Returns the browser version information.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<string> Version() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_browser_version(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterString.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    

    
    /// <exception cref="XcelerateException"></exception>
    public static async Task<Browser> Launch (BrowserConfig @config) {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        _UniFFILib.uniffi_xcelerate_core_fn_constructor_browser_launch(FfiConverterTypeBrowserConfig.INSTANCE.Lower(@config)),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypeBrowser.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    
}
public class FfiConverterTypeBrowser: FfiConverter<Browser, IntPtr> {
    public static FfiConverterTypeBrowser INSTANCE = new FfiConverterTypeBrowser();


    public override IntPtr Lower(Browser value) {
        return value.CallWithPointer(thisPtr => thisPtr);
    }

    public override Browser Lift(IntPtr value) {
        return new Browser(value);
    }

    public override Browser Read(BigEndianStream stream) {
        return Lift(new IntPtr(stream.ReadLong()));
    }

    public override int AllocationSize(Browser value) {
        return 8;
    }

    public override void Write(Browser value, BigEndianStream stream) {
        stream.WriteLong(Lower(value).ToInt64());
    }
}



/// <summary>
/// Represents an HTML element in the DOM.
/// </summary>
public interface IElement {
    /// <summary>
    /// Returns the value of a specific attribute.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<string?> Attribute(string @name);
    /// <summary>
    /// Clicks the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<Element> Click();
    /// <summary>
    /// Focuses the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<Element> Focus();
    /// <summary>
    /// Hovers over the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<Element> Hover();
    /// <summary>
    /// Returns the inner HTML of the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<string> InnerHtml();
    /// <summary>
    /// Returns the visible text of the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<string> Text();
    /// <exception cref="XcelerateException"></exception>
    Task<Element> TypeText(string @text);
}
/// <summary>
/// Represents an HTML element in the DOM.
/// </summary>
public class Element : IElement, IDisposable {
    protected IntPtr pointer;
    private int _wasDestroyed = 0;
    private long _callCounter = 1;

    public Element(IntPtr pointer) {
        this.pointer = pointer;
    }

    ~Element() {
        Destroy();
    }

    protected void FreeRustArcPtr() {
        _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            _UniFFILib.uniffi_xcelerate_core_fn_free_element(this.pointer, ref status);
        });
    }

    protected IntPtr CloneRustArcPtr() {
        return _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            return _UniFFILib.uniffi_xcelerate_core_fn_clone_element(this.pointer, ref status);
        });
    }

    public void Destroy()
    {
        // Only allow a single call to this method.
        if (Interlocked.CompareExchange(ref _wasDestroyed, 1, 0) == 0)
        {
            // This decrement always matches the initial count of 1 given at creation time.
            if (Interlocked.Decrement(ref _callCounter) == 0)
            {
                FreeRustArcPtr();
            }
        }
    }

    public void Dispose()
    {
        Destroy();
        GC.SuppressFinalize(this); // Suppress finalization to avoid unnecessary GC overhead.
    }

    private void IncrementCallCounter() 
    {
        // Check and increment the call counter, to keep the object alive.
        // This needs a compare-and-set retry loop in case of concurrent updates.
        long count;
        do
        {
            count = Interlocked.Read(ref _callCounter);
            if (count == 0L) throw new System.ObjectDisposedException(String.Format("'{0}' object has already been destroyed", this.GetType().Name));
            if (count == long.MaxValue) throw new System.OverflowException(String.Format("'{0}' call counter would overflow", this.GetType().Name));

        } while (Interlocked.CompareExchange(ref _callCounter, count + 1, count) != count);
    }

    private void DecrementCallCounter() 
    {
        // This decrement always matches the increment we performed above.
        if (Interlocked.Decrement(ref _callCounter) == 0) {
            FreeRustArcPtr();
        }
    }

    internal void CallWithPointer(Action<IntPtr> action)
    {
        IncrementCallCounter();
        try {
            action(CloneRustArcPtr());
        }
        finally {
            DecrementCallCounter();
        }
    }

    internal T CallWithPointer<T>(Func<IntPtr, T> func)
    {   
        IncrementCallCounter();
        try {
            return func(CloneRustArcPtr());
        }
        finally {
            DecrementCallCounter();
        }
    }

    
    /// <summary>
    /// Returns the value of a specific attribute.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<string?> Attribute(string @name) {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_element_attribute(thisPtr, FfiConverterString.INSTANCE.Lower(@name));
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterOptionalString.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Clicks the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<Element> Click() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_element_click(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypeElement.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Focuses the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<Element> Focus() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_element_focus(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypeElement.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Hovers over the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<Element> Hover() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_element_hover(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypeElement.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Returns the inner HTML of the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<string> InnerHtml() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_element_inner_html(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterString.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Returns the visible text of the element.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<string> Text() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_element_text(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterString.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <exception cref="XcelerateException"></exception>
    public async Task<Element> TypeText(string @text) {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_element_type_text(thisPtr, FfiConverterString.INSTANCE.Lower(@text));
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypeElement.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    

    
}
public class FfiConverterTypeElement: FfiConverter<Element, IntPtr> {
    public static FfiConverterTypeElement INSTANCE = new FfiConverterTypeElement();


    public override IntPtr Lower(Element value) {
        return value.CallWithPointer(thisPtr => thisPtr);
    }

    public override Element Lift(IntPtr value) {
        return new Element(value);
    }

    public override Element Read(BigEndianStream stream) {
        return Lift(new IntPtr(stream.ReadLong()));
    }

    public override int AllocationSize(Element value) {
        return 8;
    }

    public override void Write(Element value, BigEndianStream stream) {
        stream.WriteLong(Lower(value).ToInt64());
    }
}



public interface IPage {
    /// <summary>
    /// Evaluates a script on every new document.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<string> AddScriptToEvaluateOnNewDocument(string @source);
    /// <summary>
    /// Returns the full HTML content of the page.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<string> Content();
    /// <summary>
    /// Finds an element matching the CSS selector.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<Element> FindElement(string @selector);
    /// <summary>
    /// Navigates back in history.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task GoBack();
    /// <summary>
    /// Navigates to a URL.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task Navigate(string @url);
    /// <summary>
    /// Captures a PDF of the page.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<byte[]> Pdf();
    /// <summary>
    /// Reloads the page.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task Reload();
    /// <summary>
    /// Captures a screenshot of the page as a PNG.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<byte[]> Screenshot();
    /// <summary>
    /// Captures a full-page screenshot by overriding device metrics.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<byte[]> ScreenshotFull();
    /// <summary>
    /// Returns the page title.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<string> Title();
    /// <summary>
    /// Waits for the page to finish loading.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task WaitForNavigation();
    /// <summary>
    /// Waits for an element matching the selector to appear in the DOM.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    Task<Element> WaitForSelector(string @selector);
}
public class Page : IPage, IDisposable {
    protected IntPtr pointer;
    private int _wasDestroyed = 0;
    private long _callCounter = 1;

    public Page(IntPtr pointer) {
        this.pointer = pointer;
    }

    ~Page() {
        Destroy();
    }

    protected void FreeRustArcPtr() {
        _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            _UniFFILib.uniffi_xcelerate_core_fn_free_page(this.pointer, ref status);
        });
    }

    protected IntPtr CloneRustArcPtr() {
        return _UniffiHelpers.RustCall((ref UniffiRustCallStatus status) => {
            return _UniFFILib.uniffi_xcelerate_core_fn_clone_page(this.pointer, ref status);
        });
    }

    public void Destroy()
    {
        // Only allow a single call to this method.
        if (Interlocked.CompareExchange(ref _wasDestroyed, 1, 0) == 0)
        {
            // This decrement always matches the initial count of 1 given at creation time.
            if (Interlocked.Decrement(ref _callCounter) == 0)
            {
                FreeRustArcPtr();
            }
        }
    }

    public void Dispose()
    {
        Destroy();
        GC.SuppressFinalize(this); // Suppress finalization to avoid unnecessary GC overhead.
    }

    private void IncrementCallCounter() 
    {
        // Check and increment the call counter, to keep the object alive.
        // This needs a compare-and-set retry loop in case of concurrent updates.
        long count;
        do
        {
            count = Interlocked.Read(ref _callCounter);
            if (count == 0L) throw new System.ObjectDisposedException(String.Format("'{0}' object has already been destroyed", this.GetType().Name));
            if (count == long.MaxValue) throw new System.OverflowException(String.Format("'{0}' call counter would overflow", this.GetType().Name));

        } while (Interlocked.CompareExchange(ref _callCounter, count + 1, count) != count);
    }

    private void DecrementCallCounter() 
    {
        // This decrement always matches the increment we performed above.
        if (Interlocked.Decrement(ref _callCounter) == 0) {
            FreeRustArcPtr();
        }
    }

    internal void CallWithPointer(Action<IntPtr> action)
    {
        IncrementCallCounter();
        try {
            action(CloneRustArcPtr());
        }
        finally {
            DecrementCallCounter();
        }
    }

    internal T CallWithPointer<T>(Func<IntPtr, T> func)
    {   
        IncrementCallCounter();
        try {
            return func(CloneRustArcPtr());
        }
        finally {
            DecrementCallCounter();
        }
    }

    
    /// <summary>
    /// Evaluates a script on every new document.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<string> AddScriptToEvaluateOnNewDocument(string @source) {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_add_script_to_evaluate_on_new_document(thisPtr, FfiConverterString.INSTANCE.Lower(@source));
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterString.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Returns the full HTML content of the page.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<string> Content() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_content(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterString.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Finds an element matching the CSS selector.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<Element> FindElement(string @selector) {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_find_element(thisPtr, FfiConverterString.INSTANCE.Lower(@selector));
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypeElement.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Navigates back in history.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task GoBack() {await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_go_back(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_void(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {_UniFFILib.ffi_xcelerate_core_rust_future_complete_void(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_void(future),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Navigates to a URL.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task Navigate(string @url) {await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_navigate(thisPtr, FfiConverterString.INSTANCE.Lower(@url));
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_void(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {_UniFFILib.ffi_xcelerate_core_rust_future_complete_void(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_void(future),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Captures a PDF of the page.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<byte[]> Pdf() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_pdf(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterByteArray.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Reloads the page.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task Reload() {await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_reload(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_void(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {_UniFFILib.ffi_xcelerate_core_rust_future_complete_void(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_void(future),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Captures a screenshot of the page as a PNG.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<byte[]> Screenshot() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_screenshot(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterByteArray.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Captures a full-page screenshot by overriding device metrics.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<byte[]> ScreenshotFull() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_screenshot_full(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterByteArray.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Returns the page title.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<string> Title() {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_title(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_rust_buffer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_rust_buffer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_rust_buffer(future),
        // Lift
        (result) => FfiConverterString.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Waits for the page to finish loading.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task WaitForNavigation() {await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_wait_for_navigation(thisPtr);
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_void(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {_UniFFILib.ffi_xcelerate_core_rust_future_complete_void(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_void(future),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    
    /// <summary>
    /// Waits for an element matching the selector to appear in the DOM.
    /// </summary>
    /// <exception cref="XcelerateException"></exception>
    public async Task<Element> WaitForSelector(string @selector) {
    return await _UniFFIAsync.UniffiRustCallAsync(
        // Get rust future
        CallWithPointer(thisPtr => {
            return _UniFFILib.uniffi_xcelerate_core_fn_method_page_wait_for_selector(thisPtr, FfiConverterString.INSTANCE.Lower(@selector));
        }),
        // Poll
        (IntPtr future, IntPtr continuation, IntPtr data) => _UniFFILib.ffi_xcelerate_core_rust_future_poll_pointer(future, continuation, data),
        // Complete
        (IntPtr future, ref UniffiRustCallStatus status) => {
            return _UniFFILib.ffi_xcelerate_core_rust_future_complete_pointer(future, ref status);
        },
        // Free
        (IntPtr future) => _UniFFILib.ffi_xcelerate_core_rust_future_free_pointer(future),
        // Lift
        (result) => FfiConverterTypeElement.INSTANCE.Lift(result),
        // Error
        FfiConverterTypeXcelerateError.INSTANCE
    );
    }
    

    
}
public class FfiConverterTypePage: FfiConverter<Page, IntPtr> {
    public static FfiConverterTypePage INSTANCE = new FfiConverterTypePage();


    public override IntPtr Lower(Page value) {
        return value.CallWithPointer(thisPtr => thisPtr);
    }

    public override Page Lift(IntPtr value) {
        return new Page(value);
    }

    public override Page Read(BigEndianStream stream) {
        return Lift(new IntPtr(stream.ReadLong()));
    }

    public override int AllocationSize(Page value) {
        return 8;
    }

    public override void Write(Page value, BigEndianStream stream) {
        stream.WriteLong(Lower(value).ToInt64());
    }
}



/// <summary>
/// Configuration for the Browser instance.
/// </summary>
/// <param name="headless">
/// Whether to run the browser in headless mode.
/// </param>
/// <param name="stealth">
/// Whether to apply stealth patches to the binary.
/// </param>
/// <param name="detached">
/// Whether to run the browser as a detached process.
/// </param>
/// <param name="executable_path">
/// Optional path to the browser executable.
/// </param>
public record BrowserConfig (
    /// <summary>
    /// Whether to run the browser in headless mode.
    /// </summary>
    bool @headless, 
    /// <summary>
    /// Whether to apply stealth patches to the binary.
    /// </summary>
    bool @stealth, 
    /// <summary>
    /// Whether to run the browser as a detached process.
    /// </summary>
    bool @detached, 
    /// <summary>
    /// Optional path to the browser executable.
    /// </summary>
    string? @executablePath
) {
}

public class FfiConverterTypeBrowserConfig: FfiConverterRustBuffer<BrowserConfig> {
    public static FfiConverterTypeBrowserConfig INSTANCE = new FfiConverterTypeBrowserConfig();

    public override BrowserConfig Read(BigEndianStream stream) {
        return new BrowserConfig(
            @headless: FfiConverterBoolean.INSTANCE.Read(stream),
            @stealth: FfiConverterBoolean.INSTANCE.Read(stream),
            @detached: FfiConverterBoolean.INSTANCE.Read(stream),
            @executablePath: FfiConverterOptionalString.INSTANCE.Read(stream)
        );
    }

    public override int AllocationSize(BrowserConfig value) {
        return 0
            + FfiConverterBoolean.INSTANCE.AllocationSize(value.@headless)
            + FfiConverterBoolean.INSTANCE.AllocationSize(value.@stealth)
            + FfiConverterBoolean.INSTANCE.AllocationSize(value.@detached)
            + FfiConverterOptionalString.INSTANCE.AllocationSize(value.@executablePath);
    }

    public override void Write(BrowserConfig value, BigEndianStream stream) {
            FfiConverterBoolean.INSTANCE.Write(value.@headless, stream);
            FfiConverterBoolean.INSTANCE.Write(value.@stealth, stream);
            FfiConverterBoolean.INSTANCE.Write(value.@detached, stream);
            FfiConverterOptionalString.INSTANCE.Write(value.@executablePath, stream);
    }
}





public class XcelerateException: UniffiException {
    XcelerateException(string message): base(message) {}

    // Each variant is a nested class
    // Flat enums carries a string error message, so no special implementation is necessary.
    
    public class WsException: XcelerateException {
        public WsException(string message): base(message) {}
    }
    
    public class SerdeException: XcelerateException {
        public SerdeException(string message): base(message) {}
    }
    
    public class CdpResponseException: XcelerateException {
        public CdpResponseException(string message): base(message) {}
    }
    
    public class HttpException: XcelerateException {
        public HttpException(string message): base(message) {}
    }
    
    public class NotFound: XcelerateException {
        public NotFound(string message): base(message) {}
    }
    
    public class InternalException: XcelerateException {
        public InternalException(string message): base(message) {}
    }
    
}

public class FfiConverterTypeXcelerateError : FfiConverterRustBuffer<XcelerateException>, CallStatusErrorHandler<XcelerateException> {
    public static FfiConverterTypeXcelerateError INSTANCE = new FfiConverterTypeXcelerateError();

    public override XcelerateException Read(BigEndianStream stream) {
        var value = stream.ReadInt();
        switch (value) {
            case 1: return new XcelerateException.WsException(FfiConverterString.INSTANCE.Read(stream));
            case 2: return new XcelerateException.SerdeException(FfiConverterString.INSTANCE.Read(stream));
            case 3: return new XcelerateException.CdpResponseException(FfiConverterString.INSTANCE.Read(stream));
            case 4: return new XcelerateException.HttpException(FfiConverterString.INSTANCE.Read(stream));
            case 5: return new XcelerateException.NotFound(FfiConverterString.INSTANCE.Read(stream));
            case 6: return new XcelerateException.InternalException(FfiConverterString.INSTANCE.Read(stream));
            default:
                throw new InternalException(String.Format("invalid error value '{0}' in FfiConverterTypeXcelerateError.Read()", value));
        }
    }

    public override int AllocationSize(XcelerateException value) {
        return 4 + FfiConverterString.INSTANCE.AllocationSize(value.Message);
    }

    public override void Write(XcelerateException value, BigEndianStream stream) {
        switch (value) {
            case XcelerateException.WsException:
                stream.WriteInt(1);
                break;
            case XcelerateException.SerdeException:
                stream.WriteInt(2);
                break;
            case XcelerateException.CdpResponseException:
                stream.WriteInt(3);
                break;
            case XcelerateException.HttpException:
                stream.WriteInt(4);
                break;
            case XcelerateException.NotFound:
                stream.WriteInt(5);
                break;
            case XcelerateException.InternalException:
                stream.WriteInt(6);
                break;
            default:
                throw new InternalException(String.Format("invalid error value '{0}' in FfiConverterTypeXcelerateError.Write()", value));
        }
    }
}




public class FfiConverterOptionalString: FfiConverterRustBuffer<string?> {
    public static FfiConverterOptionalString INSTANCE = new FfiConverterOptionalString();

    public override string? Read(BigEndianStream stream) {
        if (stream.ReadByte() == 0) {
            return null;
        }
        return FfiConverterString.INSTANCE.Read(stream);
    }

    public override int AllocationSize(string? value) {
        if (value == null) {
            return 1;
        } else {
            return 1 + FfiConverterString.INSTANCE.AllocationSize((string)value);
        }
    }

    public override void Write(string? value, BigEndianStream stream) {
        if (value == null) {
            stream.WriteByte(0);
        } else {
            stream.WriteByte(1);
            FfiConverterString.INSTANCE.Write((string)value, stream);
        }
    }
}



public class ConcurrentHandleMap<T> where T: notnull {
    Dictionary<ulong, T> map = new Dictionary<ulong, T>();

    Object lock_ = new Object();
    ulong currentHandle = 0;

    public ulong Insert(T obj) {
        lock (lock_) {
            currentHandle += 1;
            map[currentHandle] = obj;
            return currentHandle;
        }
    }

    public bool TryGet(ulong handle, out T result) {
        lock (lock_) {
            #pragma warning disable 8601 // Possible null reference assignment
            return map.TryGetValue(handle, out result);
            #pragma warning restore 8601

        }
    }

    public T Get(ulong handle) {
        if (TryGet(handle, out var result)) {
            return result;
        } else {
            throw new InternalException("ConcurrentHandleMap: Invalid handle");
        }
    }

    public bool Remove(ulong handle) {
        return Remove(handle, out T result);
    }

    public bool Remove(ulong handle, out T result) {
        lock (lock_) {
            // Possible null reference assignment
            #pragma warning disable 8601

            if (map.TryGetValue(handle, out result)) {
            #pragma warning restore 8601

                map.Remove(handle);
                return true;
            } else {
                return false;
            }
        }
    }
}

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
delegate void UniFfiFutureCallback(IntPtr continuationHandle, byte pollResult);

internal static class _UniFFIAsync {
    internal const byte UNIFFI_RUST_FUTURE_POLL_READY = 0;
    // internal const byte UNIFFI_RUST_FUTURE_POLL_MAYBE_READY = 1;

    internal static ConcurrentHandleMap<TaskCompletionSource<byte>> _async_handle_map = new ConcurrentHandleMap<TaskCompletionSource<byte>>();
    public static ConcurrentHandleMap<CancellationTokenSource> _foreign_futures_map = new ConcurrentHandleMap<CancellationTokenSource>();

    // FFI type for Rust future continuations
    public class UniffiRustFutureContinuationCallback
    {
        public static UniFfiFutureCallback callback = Callback;

        public static void Callback(IntPtr continuationHandle, byte pollResult)
        {
            if (_async_handle_map.Remove((ulong)continuationHandle.ToInt64(), out TaskCompletionSource<byte> task))
            {
                task.SetResult(pollResult);
            }
            else 
            {
                throw new InternalException($"Unable to find continuation handle: {continuationHandle}");
            }
        }
    }

    public class UniffiForeignFutureFreeCallback
    {
        public static _UniFFILib.UniffiForeignFutureFree callback = Callback;

        public static void Callback(ulong handle)
        {
            if (_foreign_futures_map.Remove(handle, out CancellationTokenSource task))
            {
                task.Cancel();
            }
            else
            {
                throw new InternalException($"Unable to find cancellation token: {handle}");
            }
        }
    }

    public delegate F CompleteFuncDelegate<F>(IntPtr ptr, ref UniffiRustCallStatus status);

    public delegate void CompleteActionDelegate(IntPtr ptr, ref UniffiRustCallStatus status);

    private static async Task PollFuture(IntPtr rustFuture, Action<IntPtr, IntPtr, IntPtr> pollFunc)
    {
        byte pollResult;
        do 
        {
            var tcs = new TaskCompletionSource<byte>(TaskCreationOptions.RunContinuationsAsynchronously);
            IntPtr callback = Marshal.GetFunctionPointerForDelegate(UniffiRustFutureContinuationCallback.callback);
            ulong mapEntry = _async_handle_map.Insert(tcs);
            pollFunc(rustFuture, callback, (IntPtr)mapEntry);
            pollResult = await tcs.Task;
        }
        while(pollResult != UNIFFI_RUST_FUTURE_POLL_READY);
    }

    public static async Task<T> UniffiRustCallAsync<T, F, E>(
        IntPtr rustFuture,
        Action<IntPtr, IntPtr, IntPtr> pollFunc,
        CompleteFuncDelegate<F> completeFunc,
        Action<IntPtr> freeFunc,
        Func<F, T> liftFunc,
        CallStatusErrorHandler<E> errorHandler
    ) where E : UniffiException
    {
        try {
            await PollFuture(rustFuture, pollFunc);
            var result = _UniffiHelpers.RustCallWithError(errorHandler, (ref UniffiRustCallStatus status) => completeFunc(rustFuture, ref status));
            return liftFunc(result);
        }
        finally
        {
            freeFunc(rustFuture);
        }
    }

    public static async Task UniffiRustCallAsync<E>(
        IntPtr rustFuture,
        Action<IntPtr, IntPtr, IntPtr> pollFunc,
        CompleteActionDelegate completeFunc,
        Action<IntPtr> freeFunc,
        CallStatusErrorHandler<E> errorHandler
    ) where E : UniffiException
    {
         try {
            await PollFuture(rustFuture, pollFunc);
            _UniffiHelpers.RustCallWithError(errorHandler, (ref UniffiRustCallStatus status) => completeFunc(rustFuture, ref status));

        }
        finally
        {
            freeFunc(rustFuture);
        }
    }
}
#pragma warning restore 8625

internal static class XcelerateCoreMethods {
}