﻿//
// DO NOT MODIFY! THIS IS AUTOGENERATED FILE!
//
namespace Xilium.CefGlue.Interop
{
    using System;
    using System.Diagnostics.CodeAnalysis;
    using System.Runtime.InteropServices;
    using System.Security;
    
    [StructLayout(LayoutKind.Sequential, Pack = libcef.ALIGN)]
    [SuppressMessage("Microsoft.Design", "CA1049:TypesThatOwnNativeResourcesShouldBeDisposable")]
    internal unsafe struct cef_v8value_t
    {
        internal cef_base_ref_counted_t _base;
        internal IntPtr _is_valid;
        internal IntPtr _is_undefined;
        internal IntPtr _is_null;
        internal IntPtr _is_bool;
        internal IntPtr _is_int;
        internal IntPtr _is_uint;
        internal IntPtr _is_double;
        internal IntPtr _is_date;
        internal IntPtr _is_string;
        internal IntPtr _is_object;
        internal IntPtr _is_array;
        internal IntPtr _is_array_buffer;
        internal IntPtr _is_function;
        internal IntPtr _is_same;
        internal IntPtr _get_bool_value;
        internal IntPtr _get_int_value;
        internal IntPtr _get_uint_value;
        internal IntPtr _get_double_value;
        internal IntPtr _get_date_value;
        internal IntPtr _get_string_value;
        internal IntPtr _is_user_created;
        internal IntPtr _has_exception;
        internal IntPtr _get_exception;
        internal IntPtr _clear_exception;
        internal IntPtr _will_rethrow_exceptions;
        internal IntPtr _set_rethrow_exceptions;
        internal IntPtr _has_value_bykey;
        internal IntPtr _has_value_byindex;
        internal IntPtr _delete_value_bykey;
        internal IntPtr _delete_value_byindex;
        internal IntPtr _get_value_bykey;
        internal IntPtr _get_value_byindex;
        internal IntPtr _set_value_bykey;
        internal IntPtr _set_value_byindex;
        internal IntPtr _set_value_byaccessor;
        internal IntPtr _get_keys;
        internal IntPtr _set_user_data;
        internal IntPtr _get_user_data;
        internal IntPtr _get_externally_allocated_memory;
        internal IntPtr _adjust_externally_allocated_memory;
        internal IntPtr _get_array_length;
        internal IntPtr _get_array_buffer_release_callback;
        internal IntPtr _neuter_array_buffer;
        internal IntPtr _get_function_name;
        internal IntPtr _get_function_handler;
        internal IntPtr _execute_function;
        internal IntPtr _execute_function_with_context;
        
        // CreateUndefined
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_undefined", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_undefined();
        
        // CreateNull
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_null", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_null();
        
        // CreateBool
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_bool", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_bool(int value);
        
        // CreateInt
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_int", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_int(int value);
        
        // CreateUInt
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_uint", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_uint(uint value);
        
        // CreateDouble
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_double", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_double(double value);
        
        // CreateDate
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_date", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_date(cef_time_t* date);
        
        // CreateString
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_string", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_string(cef_string_t* value);
        
        // CreateObject
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_object", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_object(cef_v8accessor_t* accessor, cef_v8interceptor_t* interceptor);
        
        // CreateArray
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_array", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_array(int length);
        
        // CreateArrayBuffer
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_array_buffer", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_array_buffer(void* buffer, UIntPtr length, cef_v8array_buffer_release_callback_t* release_callback);
        
        // CreateFunction
        [DllImport(libcef.DllName, EntryPoint = "cef_v8value_create_function", CallingConvention = libcef.CEF_CALL)]
        public static extern cef_v8value_t* create_function(cef_string_t* name, cef_v8handler_t* handler);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate void add_ref_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int release_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int has_one_ref_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int has_at_least_one_ref_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_valid_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_undefined_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_null_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_bool_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_int_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_uint_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_double_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_date_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_string_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_object_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_array_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_array_buffer_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_function_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_same_delegate(cef_v8value_t* self, cef_v8value_t* that);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int get_bool_value_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int get_int_value_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate uint get_uint_value_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate double get_double_value_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_time_t get_date_value_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_string_userfree* get_string_value_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int is_user_created_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int has_exception_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_v8exception_t* get_exception_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int clear_exception_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int will_rethrow_exceptions_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int set_rethrow_exceptions_delegate(cef_v8value_t* self, int rethrow);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int has_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int has_value_byindex_delegate(cef_v8value_t* self, int index);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int delete_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int delete_value_byindex_delegate(cef_v8value_t* self, int index);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_v8value_t* get_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_v8value_t* get_value_byindex_delegate(cef_v8value_t* self, int index);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int set_value_bykey_delegate(cef_v8value_t* self, cef_string_t* key, cef_v8value_t* value, CefV8PropertyAttribute attribute);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int set_value_byindex_delegate(cef_v8value_t* self, int index, cef_v8value_t* value);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int set_value_byaccessor_delegate(cef_v8value_t* self, cef_string_t* key, CefV8AccessControl settings, CefV8PropertyAttribute attribute);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int get_keys_delegate(cef_v8value_t* self, cef_string_list* keys);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int set_user_data_delegate(cef_v8value_t* self, cef_base_ref_counted_t* user_data);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_base_ref_counted_t* get_user_data_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int get_externally_allocated_memory_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int adjust_externally_allocated_memory_delegate(cef_v8value_t* self, int change_in_bytes);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int get_array_length_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_v8array_buffer_release_callback_t* get_array_buffer_release_callback_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate int neuter_array_buffer_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_string_userfree* get_function_name_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_v8handler_t* get_function_handler_delegate(cef_v8value_t* self);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_v8value_t* execute_function_delegate(cef_v8value_t* self, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments);
        
        [UnmanagedFunctionPointer(libcef.CEF_CALLBACK)]
        #if !DEBUG
        [SuppressUnmanagedCodeSecurity]
        #endif
        private delegate cef_v8value_t* execute_function_with_context_delegate(cef_v8value_t* self, cef_v8context_t* context, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments);
        
        // AddRef
        private static IntPtr _p0;
        private static add_ref_delegate _d0;
        
        public static void add_ref(cef_v8value_t* self)
        {
            add_ref_delegate d;
            var p = self->_base._add_ref;
            if (p == _p0) { d = _d0; }
            else
            {
                d = (add_ref_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(add_ref_delegate));
                if (_p0 == IntPtr.Zero) { _d0 = d; _p0 = p; }
            }
            d(self);
        }
        
        // Release
        private static IntPtr _p1;
        private static release_delegate _d1;
        
        public static int release(cef_v8value_t* self)
        {
            release_delegate d;
            var p = self->_base._release;
            if (p == _p1) { d = _d1; }
            else
            {
                d = (release_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(release_delegate));
                if (_p1 == IntPtr.Zero) { _d1 = d; _p1 = p; }
            }
            return d(self);
        }
        
        // HasOneRef
        private static IntPtr _p2;
        private static has_one_ref_delegate _d2;
        
        public static int has_one_ref(cef_v8value_t* self)
        {
            has_one_ref_delegate d;
            var p = self->_base._has_one_ref;
            if (p == _p2) { d = _d2; }
            else
            {
                d = (has_one_ref_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_one_ref_delegate));
                if (_p2 == IntPtr.Zero) { _d2 = d; _p2 = p; }
            }
            return d(self);
        }
        
        // HasAtLeastOneRef
        private static IntPtr _p3;
        private static has_at_least_one_ref_delegate _d3;
        
        public static int has_at_least_one_ref(cef_v8value_t* self)
        {
            has_at_least_one_ref_delegate d;
            var p = self->_base._has_at_least_one_ref;
            if (p == _p3) { d = _d3; }
            else
            {
                d = (has_at_least_one_ref_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_at_least_one_ref_delegate));
                if (_p3 == IntPtr.Zero) { _d3 = d; _p3 = p; }
            }
            return d(self);
        }
        
        // IsValid
        private static IntPtr _p4;
        private static is_valid_delegate _d4;
        
        public static int is_valid(cef_v8value_t* self)
        {
            is_valid_delegate d;
            var p = self->_is_valid;
            if (p == _p4) { d = _d4; }
            else
            {
                d = (is_valid_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_valid_delegate));
                if (_p4 == IntPtr.Zero) { _d4 = d; _p4 = p; }
            }
            return d(self);
        }
        
        // IsUndefined
        private static IntPtr _p5;
        private static is_undefined_delegate _d5;
        
        public static int is_undefined(cef_v8value_t* self)
        {
            is_undefined_delegate d;
            var p = self->_is_undefined;
            if (p == _p5) { d = _d5; }
            else
            {
                d = (is_undefined_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_undefined_delegate));
                if (_p5 == IntPtr.Zero) { _d5 = d; _p5 = p; }
            }
            return d(self);
        }
        
        // IsNull
        private static IntPtr _p6;
        private static is_null_delegate _d6;
        
        public static int is_null(cef_v8value_t* self)
        {
            is_null_delegate d;
            var p = self->_is_null;
            if (p == _p6) { d = _d6; }
            else
            {
                d = (is_null_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_null_delegate));
                if (_p6 == IntPtr.Zero) { _d6 = d; _p6 = p; }
            }
            return d(self);
        }
        
        // IsBool
        private static IntPtr _p7;
        private static is_bool_delegate _d7;
        
        public static int is_bool(cef_v8value_t* self)
        {
            is_bool_delegate d;
            var p = self->_is_bool;
            if (p == _p7) { d = _d7; }
            else
            {
                d = (is_bool_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_bool_delegate));
                if (_p7 == IntPtr.Zero) { _d7 = d; _p7 = p; }
            }
            return d(self);
        }
        
        // IsInt
        private static IntPtr _p8;
        private static is_int_delegate _d8;
        
        public static int is_int(cef_v8value_t* self)
        {
            is_int_delegate d;
            var p = self->_is_int;
            if (p == _p8) { d = _d8; }
            else
            {
                d = (is_int_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_int_delegate));
                if (_p8 == IntPtr.Zero) { _d8 = d; _p8 = p; }
            }
            return d(self);
        }
        
        // IsUInt
        private static IntPtr _p9;
        private static is_uint_delegate _d9;
        
        public static int is_uint(cef_v8value_t* self)
        {
            is_uint_delegate d;
            var p = self->_is_uint;
            if (p == _p9) { d = _d9; }
            else
            {
                d = (is_uint_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_uint_delegate));
                if (_p9 == IntPtr.Zero) { _d9 = d; _p9 = p; }
            }
            return d(self);
        }
        
        // IsDouble
        private static IntPtr _pa;
        private static is_double_delegate _da;
        
        public static int is_double(cef_v8value_t* self)
        {
            is_double_delegate d;
            var p = self->_is_double;
            if (p == _pa) { d = _da; }
            else
            {
                d = (is_double_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_double_delegate));
                if (_pa == IntPtr.Zero) { _da = d; _pa = p; }
            }
            return d(self);
        }
        
        // IsDate
        private static IntPtr _pb;
        private static is_date_delegate _db;
        
        public static int is_date(cef_v8value_t* self)
        {
            is_date_delegate d;
            var p = self->_is_date;
            if (p == _pb) { d = _db; }
            else
            {
                d = (is_date_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_date_delegate));
                if (_pb == IntPtr.Zero) { _db = d; _pb = p; }
            }
            return d(self);
        }
        
        // IsString
        private static IntPtr _pc;
        private static is_string_delegate _dc;
        
        public static int is_string(cef_v8value_t* self)
        {
            is_string_delegate d;
            var p = self->_is_string;
            if (p == _pc) { d = _dc; }
            else
            {
                d = (is_string_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_string_delegate));
                if (_pc == IntPtr.Zero) { _dc = d; _pc = p; }
            }
            return d(self);
        }
        
        // IsObject
        private static IntPtr _pd;
        private static is_object_delegate _dd;
        
        public static int is_object(cef_v8value_t* self)
        {
            is_object_delegate d;
            var p = self->_is_object;
            if (p == _pd) { d = _dd; }
            else
            {
                d = (is_object_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_object_delegate));
                if (_pd == IntPtr.Zero) { _dd = d; _pd = p; }
            }
            return d(self);
        }
        
        // IsArray
        private static IntPtr _pe;
        private static is_array_delegate _de;
        
        public static int is_array(cef_v8value_t* self)
        {
            is_array_delegate d;
            var p = self->_is_array;
            if (p == _pe) { d = _de; }
            else
            {
                d = (is_array_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_array_delegate));
                if (_pe == IntPtr.Zero) { _de = d; _pe = p; }
            }
            return d(self);
        }
        
        // IsArrayBuffer
        private static IntPtr _pf;
        private static is_array_buffer_delegate _df;
        
        public static int is_array_buffer(cef_v8value_t* self)
        {
            is_array_buffer_delegate d;
            var p = self->_is_array_buffer;
            if (p == _pf) { d = _df; }
            else
            {
                d = (is_array_buffer_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_array_buffer_delegate));
                if (_pf == IntPtr.Zero) { _df = d; _pf = p; }
            }
            return d(self);
        }
        
        // IsFunction
        private static IntPtr _p10;
        private static is_function_delegate _d10;
        
        public static int is_function(cef_v8value_t* self)
        {
            is_function_delegate d;
            var p = self->_is_function;
            if (p == _p10) { d = _d10; }
            else
            {
                d = (is_function_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_function_delegate));
                if (_p10 == IntPtr.Zero) { _d10 = d; _p10 = p; }
            }
            return d(self);
        }
        
        // IsSame
        private static IntPtr _p11;
        private static is_same_delegate _d11;
        
        public static int is_same(cef_v8value_t* self, cef_v8value_t* that)
        {
            is_same_delegate d;
            var p = self->_is_same;
            if (p == _p11) { d = _d11; }
            else
            {
                d = (is_same_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_same_delegate));
                if (_p11 == IntPtr.Zero) { _d11 = d; _p11 = p; }
            }
            return d(self, that);
        }
        
        // GetBoolValue
        private static IntPtr _p12;
        private static get_bool_value_delegate _d12;
        
        public static int get_bool_value(cef_v8value_t* self)
        {
            get_bool_value_delegate d;
            var p = self->_get_bool_value;
            if (p == _p12) { d = _d12; }
            else
            {
                d = (get_bool_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_bool_value_delegate));
                if (_p12 == IntPtr.Zero) { _d12 = d; _p12 = p; }
            }
            return d(self);
        }
        
        // GetIntValue
        private static IntPtr _p13;
        private static get_int_value_delegate _d13;
        
        public static int get_int_value(cef_v8value_t* self)
        {
            get_int_value_delegate d;
            var p = self->_get_int_value;
            if (p == _p13) { d = _d13; }
            else
            {
                d = (get_int_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_int_value_delegate));
                if (_p13 == IntPtr.Zero) { _d13 = d; _p13 = p; }
            }
            return d(self);
        }
        
        // GetUIntValue
        private static IntPtr _p14;
        private static get_uint_value_delegate _d14;
        
        public static uint get_uint_value(cef_v8value_t* self)
        {
            get_uint_value_delegate d;
            var p = self->_get_uint_value;
            if (p == _p14) { d = _d14; }
            else
            {
                d = (get_uint_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_uint_value_delegate));
                if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; }
            }
            return d(self);
        }
        
        // GetDoubleValue
        private static IntPtr _p15;
        private static get_double_value_delegate _d15;
        
        public static double get_double_value(cef_v8value_t* self)
        {
            get_double_value_delegate d;
            var p = self->_get_double_value;
            if (p == _p15) { d = _d15; }
            else
            {
                d = (get_double_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_double_value_delegate));
                if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; }
            }
            return d(self);
        }
        
        // GetDateValue
        private static IntPtr _p16;
        private static get_date_value_delegate _d16;
        
        public static cef_time_t get_date_value(cef_v8value_t* self)
        {
            get_date_value_delegate d;
            var p = self->_get_date_value;
            if (p == _p16) { d = _d16; }
            else
            {
                d = (get_date_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_date_value_delegate));
                if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; }
            }
            return d(self);
        }
        
        // GetStringValue
        private static IntPtr _p17;
        private static get_string_value_delegate _d17;
        
        public static cef_string_userfree* get_string_value(cef_v8value_t* self)
        {
            get_string_value_delegate d;
            var p = self->_get_string_value;
            if (p == _p17) { d = _d17; }
            else
            {
                d = (get_string_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_string_value_delegate));
                if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; }
            }
            return d(self);
        }
        
        // IsUserCreated
        private static IntPtr _p18;
        private static is_user_created_delegate _d18;
        
        public static int is_user_created(cef_v8value_t* self)
        {
            is_user_created_delegate d;
            var p = self->_is_user_created;
            if (p == _p18) { d = _d18; }
            else
            {
                d = (is_user_created_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_user_created_delegate));
                if (_p18 == IntPtr.Zero) { _d18 = d; _p18 = p; }
            }
            return d(self);
        }
        
        // HasException
        private static IntPtr _p19;
        private static has_exception_delegate _d19;
        
        public static int has_exception(cef_v8value_t* self)
        {
            has_exception_delegate d;
            var p = self->_has_exception;
            if (p == _p19) { d = _d19; }
            else
            {
                d = (has_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_exception_delegate));
                if (_p19 == IntPtr.Zero) { _d19 = d; _p19 = p; }
            }
            return d(self);
        }
        
        // GetException
        private static IntPtr _p1a;
        private static get_exception_delegate _d1a;
        
        public static cef_v8exception_t* get_exception(cef_v8value_t* self)
        {
            get_exception_delegate d;
            var p = self->_get_exception;
            if (p == _p1a) { d = _d1a; }
            else
            {
                d = (get_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_exception_delegate));
                if (_p1a == IntPtr.Zero) { _d1a = d; _p1a = p; }
            }
            return d(self);
        }
        
        // ClearException
        private static IntPtr _p1b;
        private static clear_exception_delegate _d1b;
        
        public static int clear_exception(cef_v8value_t* self)
        {
            clear_exception_delegate d;
            var p = self->_clear_exception;
            if (p == _p1b) { d = _d1b; }
            else
            {
                d = (clear_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(clear_exception_delegate));
                if (_p1b == IntPtr.Zero) { _d1b = d; _p1b = p; }
            }
            return d(self);
        }
        
        // WillRethrowExceptions
        private static IntPtr _p1c;
        private static will_rethrow_exceptions_delegate _d1c;
        
        public static int will_rethrow_exceptions(cef_v8value_t* self)
        {
            will_rethrow_exceptions_delegate d;
            var p = self->_will_rethrow_exceptions;
            if (p == _p1c) { d = _d1c; }
            else
            {
                d = (will_rethrow_exceptions_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(will_rethrow_exceptions_delegate));
                if (_p1c == IntPtr.Zero) { _d1c = d; _p1c = p; }
            }
            return d(self);
        }
        
        // SetRethrowExceptions
        private static IntPtr _p1d;
        private static set_rethrow_exceptions_delegate _d1d;
        
        public static int set_rethrow_exceptions(cef_v8value_t* self, int rethrow)
        {
            set_rethrow_exceptions_delegate d;
            var p = self->_set_rethrow_exceptions;
            if (p == _p1d) { d = _d1d; }
            else
            {
                d = (set_rethrow_exceptions_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_rethrow_exceptions_delegate));
                if (_p1d == IntPtr.Zero) { _d1d = d; _p1d = p; }
            }
            return d(self, rethrow);
        }
        
        // HasValue
        private static IntPtr _p1e;
        private static has_value_bykey_delegate _d1e;
        
        public static int has_value_bykey(cef_v8value_t* self, cef_string_t* key)
        {
            has_value_bykey_delegate d;
            var p = self->_has_value_bykey;
            if (p == _p1e) { d = _d1e; }
            else
            {
                d = (has_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_value_bykey_delegate));
                if (_p1e == IntPtr.Zero) { _d1e = d; _p1e = p; }
            }
            return d(self, key);
        }
        
        // HasValue
        private static IntPtr _p1f;
        private static has_value_byindex_delegate _d1f;
        
        public static int has_value_byindex(cef_v8value_t* self, int index)
        {
            has_value_byindex_delegate d;
            var p = self->_has_value_byindex;
            if (p == _p1f) { d = _d1f; }
            else
            {
                d = (has_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_value_byindex_delegate));
                if (_p1f == IntPtr.Zero) { _d1f = d; _p1f = p; }
            }
            return d(self, index);
        }
        
        // DeleteValue
        private static IntPtr _p20;
        private static delete_value_bykey_delegate _d20;
        
        public static int delete_value_bykey(cef_v8value_t* self, cef_string_t* key)
        {
            delete_value_bykey_delegate d;
            var p = self->_delete_value_bykey;
            if (p == _p20) { d = _d20; }
            else
            {
                d = (delete_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(delete_value_bykey_delegate));
                if (_p20 == IntPtr.Zero) { _d20 = d; _p20 = p; }
            }
            return d(self, key);
        }
        
        // DeleteValue
        private static IntPtr _p21;
        private static delete_value_byindex_delegate _d21;
        
        public static int delete_value_byindex(cef_v8value_t* self, int index)
        {
            delete_value_byindex_delegate d;
            var p = self->_delete_value_byindex;
            if (p == _p21) { d = _d21; }
            else
            {
                d = (delete_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(delete_value_byindex_delegate));
                if (_p21 == IntPtr.Zero) { _d21 = d; _p21 = p; }
            }
            return d(self, index);
        }
        
        // GetValue
        private static IntPtr _p22;
        private static get_value_bykey_delegate _d22;
        
        public static cef_v8value_t* get_value_bykey(cef_v8value_t* self, cef_string_t* key)
        {
            get_value_bykey_delegate d;
            var p = self->_get_value_bykey;
            if (p == _p22) { d = _d22; }
            else
            {
                d = (get_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_value_bykey_delegate));
                if (_p22 == IntPtr.Zero) { _d22 = d; _p22 = p; }
            }
            return d(self, key);
        }
        
        // GetValue
        private static IntPtr _p23;
        private static get_value_byindex_delegate _d23;
        
        public static cef_v8value_t* get_value_byindex(cef_v8value_t* self, int index)
        {
            get_value_byindex_delegate d;
            var p = self->_get_value_byindex;
            if (p == _p23) { d = _d23; }
            else
            {
                d = (get_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_value_byindex_delegate));
                if (_p23 == IntPtr.Zero) { _d23 = d; _p23 = p; }
            }
            return d(self, index);
        }
        
        // SetValue
        private static IntPtr _p24;
        private static set_value_bykey_delegate _d24;
        
        public static int set_value_bykey(cef_v8value_t* self, cef_string_t* key, cef_v8value_t* value, CefV8PropertyAttribute attribute)
        {
            set_value_bykey_delegate d;
            var p = self->_set_value_bykey;
            if (p == _p24) { d = _d24; }
            else
            {
                d = (set_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_bykey_delegate));
                if (_p24 == IntPtr.Zero) { _d24 = d; _p24 = p; }
            }
            return d(self, key, value, attribute);
        }
        
        // SetValue
        private static IntPtr _p25;
        private static set_value_byindex_delegate _d25;
        
        public static int set_value_byindex(cef_v8value_t* self, int index, cef_v8value_t* value)
        {
            set_value_byindex_delegate d;
            var p = self->_set_value_byindex;
            if (p == _p25) { d = _d25; }
            else
            {
                d = (set_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_byindex_delegate));
                if (_p25 == IntPtr.Zero) { _d25 = d; _p25 = p; }
            }
            return d(self, index, value);
        }
        
        // SetValue
        private static IntPtr _p26;
        private static set_value_byaccessor_delegate _d26;
        
        public static int set_value_byaccessor(cef_v8value_t* self, cef_string_t* key, CefV8AccessControl settings, CefV8PropertyAttribute attribute)
        {
            set_value_byaccessor_delegate d;
            var p = self->_set_value_byaccessor;
            if (p == _p26) { d = _d26; }
            else
            {
                d = (set_value_byaccessor_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_byaccessor_delegate));
                if (_p26 == IntPtr.Zero) { _d26 = d; _p26 = p; }
            }
            return d(self, key, settings, attribute);
        }
        
        // GetKeys
        private static IntPtr _p27;
        private static get_keys_delegate _d27;
        
        public static int get_keys(cef_v8value_t* self, cef_string_list* keys)
        {
            get_keys_delegate d;
            var p = self->_get_keys;
            if (p == _p27) { d = _d27; }
            else
            {
                d = (get_keys_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_keys_delegate));
                if (_p27 == IntPtr.Zero) { _d27 = d; _p27 = p; }
            }
            return d(self, keys);
        }
        
        // SetUserData
        private static IntPtr _p28;
        private static set_user_data_delegate _d28;
        
        public static int set_user_data(cef_v8value_t* self, cef_base_ref_counted_t* user_data)
        {
            set_user_data_delegate d;
            var p = self->_set_user_data;
            if (p == _p28) { d = _d28; }
            else
            {
                d = (set_user_data_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_user_data_delegate));
                if (_p28 == IntPtr.Zero) { _d28 = d; _p28 = p; }
            }
            return d(self, user_data);
        }
        
        // GetUserData
        private static IntPtr _p29;
        private static get_user_data_delegate _d29;
        
        public static cef_base_ref_counted_t* get_user_data(cef_v8value_t* self)
        {
            get_user_data_delegate d;
            var p = self->_get_user_data;
            if (p == _p29) { d = _d29; }
            else
            {
                d = (get_user_data_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_user_data_delegate));
                if (_p29 == IntPtr.Zero) { _d29 = d; _p29 = p; }
            }
            return d(self);
        }
        
        // GetExternallyAllocatedMemory
        private static IntPtr _p2a;
        private static get_externally_allocated_memory_delegate _d2a;
        
        public static int get_externally_allocated_memory(cef_v8value_t* self)
        {
            get_externally_allocated_memory_delegate d;
            var p = self->_get_externally_allocated_memory;
            if (p == _p2a) { d = _d2a; }
            else
            {
                d = (get_externally_allocated_memory_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_externally_allocated_memory_delegate));
                if (_p2a == IntPtr.Zero) { _d2a = d; _p2a = p; }
            }
            return d(self);
        }
        
        // AdjustExternallyAllocatedMemory
        private static IntPtr _p2b;
        private static adjust_externally_allocated_memory_delegate _d2b;
        
        public static int adjust_externally_allocated_memory(cef_v8value_t* self, int change_in_bytes)
        {
            adjust_externally_allocated_memory_delegate d;
            var p = self->_adjust_externally_allocated_memory;
            if (p == _p2b) { d = _d2b; }
            else
            {
                d = (adjust_externally_allocated_memory_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(adjust_externally_allocated_memory_delegate));
                if (_p2b == IntPtr.Zero) { _d2b = d; _p2b = p; }
            }
            return d(self, change_in_bytes);
        }
        
        // GetArrayLength
        private static IntPtr _p2c;
        private static get_array_length_delegate _d2c;
        
        public static int get_array_length(cef_v8value_t* self)
        {
            get_array_length_delegate d;
            var p = self->_get_array_length;
            if (p == _p2c) { d = _d2c; }
            else
            {
                d = (get_array_length_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_array_length_delegate));
                if (_p2c == IntPtr.Zero) { _d2c = d; _p2c = p; }
            }
            return d(self);
        }
        
        // GetArrayBufferReleaseCallback
        private static IntPtr _p2d;
        private static get_array_buffer_release_callback_delegate _d2d;
        
        public static cef_v8array_buffer_release_callback_t* get_array_buffer_release_callback(cef_v8value_t* self)
        {
            get_array_buffer_release_callback_delegate d;
            var p = self->_get_array_buffer_release_callback;
            if (p == _p2d) { d = _d2d; }
            else
            {
                d = (get_array_buffer_release_callback_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_array_buffer_release_callback_delegate));
                if (_p2d == IntPtr.Zero) { _d2d = d; _p2d = p; }
            }
            return d(self);
        }
        
        // NeuterArrayBuffer
        private static IntPtr _p2e;
        private static neuter_array_buffer_delegate _d2e;
        
        public static int neuter_array_buffer(cef_v8value_t* self)
        {
            neuter_array_buffer_delegate d;
            var p = self->_neuter_array_buffer;
            if (p == _p2e) { d = _d2e; }
            else
            {
                d = (neuter_array_buffer_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(neuter_array_buffer_delegate));
                if (_p2e == IntPtr.Zero) { _d2e = d; _p2e = p; }
            }
            return d(self);
        }
        
        // GetFunctionName
        private static IntPtr _p2f;
        private static get_function_name_delegate _d2f;
        
        public static cef_string_userfree* get_function_name(cef_v8value_t* self)
        {
            get_function_name_delegate d;
            var p = self->_get_function_name;
            if (p == _p2f) { d = _d2f; }
            else
            {
                d = (get_function_name_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_function_name_delegate));
                if (_p2f == IntPtr.Zero) { _d2f = d; _p2f = p; }
            }
            return d(self);
        }
        
        // GetFunctionHandler
        private static IntPtr _p30;
        private static get_function_handler_delegate _d30;
        
        public static cef_v8handler_t* get_function_handler(cef_v8value_t* self)
        {
            get_function_handler_delegate d;
            var p = self->_get_function_handler;
            if (p == _p30) { d = _d30; }
            else
            {
                d = (get_function_handler_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_function_handler_delegate));
                if (_p30 == IntPtr.Zero) { _d30 = d; _p30 = p; }
            }
            return d(self);
        }
        
        // ExecuteFunction
        private static IntPtr _p31;
        private static execute_function_delegate _d31;
        
        public static cef_v8value_t* execute_function(cef_v8value_t* self, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments)
        {
            execute_function_delegate d;
            var p = self->_execute_function;
            if (p == _p31) { d = _d31; }
            else
            {
                d = (execute_function_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(execute_function_delegate));
                if (_p31 == IntPtr.Zero) { _d31 = d; _p31 = p; }
            }
            return d(self, @object, argumentsCount, arguments);
        }
        
        // ExecuteFunctionWithContext
        private static IntPtr _p32;
        private static execute_function_with_context_delegate _d32;
        
        public static cef_v8value_t* execute_function_with_context(cef_v8value_t* self, cef_v8context_t* context, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments)
        {
            execute_function_with_context_delegate d;
            var p = self->_execute_function_with_context;
            if (p == _p32) { d = _d32; }
            else
            {
                d = (execute_function_with_context_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(execute_function_with_context_delegate));
                if (_p32 == IntPtr.Zero) { _d32 = d; _p32 = p; }
            }
            return d(self, context, @object, argumentsCount, arguments);
        }
        
    }
}
