// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// from webkit2gtk-gir-files
// DO NOT EDIT

use crate::Context;
use crate::ValuePropertyFlags;
use glib::object::Cast;
use glib::object::IsA;
use glib::translate::*;
use glib::StaticType;
use glib::ToValue;
use std::fmt;

glib::wrapper! {
    /// JSCValue represents a reference to a value in a [`Context`][crate::Context]. The JSCValue
    /// protects the referenced value from being garbage collected.
    ///
    /// # Implements
    ///
    /// [`ValueExt`][trait@crate::prelude::ValueExt]
    #[doc(alias = "JSCValue")]
    pub struct Value(Object<ffi::JSCValue, ffi::JSCValueClass>);

    match fn {
        type_ => || ffi::jsc_value_get_type(),
    }
}

impl Value {
    pub const NONE: Option<&'static Value> = None;

    //#[doc(alias = "jsc_value_new_array")]
    //pub fn new_array(context: &impl IsA<Context>, first_item_type: glib::types::Type, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Value {
    //    unsafe { TODO: call ffi:jsc_value_new_array() }
    //}

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //#[doc(alias = "jsc_value_new_array_buffer")]
    //pub fn new_array_buffer(context: &impl IsA<Context>, data: /*Unimplemented*/Option<Basic: Pointer>, size: usize, user_data: /*Unimplemented*/Option<Basic: Pointer>) -> Option<Value> {
    //    unsafe { TODO: call ffi:jsc_value_new_array_buffer() }
    //}

    /// Create a new [`Value`][crate::Value] referencing an array with the items from `array`. If `array`
    /// is [`None`] or empty a new empty array will be created. Elements of `array` should be
    /// pointers to a [`Value`][crate::Value].
    /// ## `context`
    /// a [`Context`][crate::Context]
    /// ## `array`
    /// a `GPtrArray`
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_array_from_garray")]
    pub fn new_array_from_garray(context: &impl IsA<Context>, array: &[Value]) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_array_from_garray(
                context.as_ref().to_glib_none().0,
                array.to_glib_none().0,
            ))
        }
    }

    /// Create a new [`Value`][crate::Value] referencing an array of strings with the items from `strv`. If `array`
    /// is [`None`] or empty a new empty array will be created.
    /// ## `context`
    /// a [`Context`][crate::Context]
    /// ## `strv`
    /// a [`None`]-terminated array of strings
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_array_from_strv")]
    pub fn new_array_from_strv(context: &impl IsA<Context>, strv: &[&str]) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_array_from_strv(
                context.as_ref().to_glib_none().0,
                strv.to_glib_none().0,
            ))
        }
    }

    /// Create a new [`Value`][crate::Value] from `value`
    /// ## `context`
    /// a [`Context`][crate::Context]
    /// ## `value`
    /// a `gboolean`
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_boolean")]
    pub fn new_boolean(context: &impl IsA<Context>, value: bool) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_boolean(
                context.as_ref().to_glib_none().0,
                value.into_glib(),
            ))
        }
    }

    /// Create a new [`Value`][crate::Value] referencing a new value created by parsing `json`.
    /// ## `context`
    /// a [`Context`][crate::Context]
    /// ## `json`
    /// the JSON string to be parsed
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    #[doc(alias = "jsc_value_new_from_json")]
    #[doc(alias = "new_from_json")]
    pub fn from_json(context: &impl IsA<Context>, json: &str) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_from_json(
                context.as_ref().to_glib_none().0,
                json.to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "jsc_value_new_function")]
    //pub fn new_function<P: Fn() + 'static>(context: &impl IsA<Context>, name: Option<&str>, callback: P, user_data: /*Unimplemented*/Option<Basic: Pointer>, return_type: glib::types::Type, n_params: u32, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Value {
    //    unsafe { TODO: call ffi:jsc_value_new_function() }
    //}

    //#[doc(alias = "jsc_value_new_function_variadic")]
    //pub fn new_function_variadic(context: &impl IsA<Context>, name: Option<&str>, callback: /*Unimplemented*/Fn(/*Ignored*/glib::PtrArray) -> Value, user_data: /*Unimplemented*/Option<Basic: Pointer>, return_type: glib::types::Type) -> Value {
    //    unsafe { TODO: call ffi:jsc_value_new_function_variadic() }
    //}

    //#[doc(alias = "jsc_value_new_functionv")]
    //pub fn new_functionv<P: Fn() + 'static>(context: &impl IsA<Context>, name: Option<&str>, callback: P, user_data: /*Unimplemented*/Option<Basic: Pointer>, return_type: glib::types::Type, n_parameters: u32) -> Value {
    //    unsafe { TODO: call ffi:jsc_value_new_functionv() }
    //}

    /// Create a new [`Value`][crate::Value] referencing `<function>`null`</function>` in `context`.
    /// ## `context`
    /// a [`Context`][crate::Context]
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_null")]
    pub fn new_null(context: &impl IsA<Context>) -> Value {
        unsafe { from_glib_full(ffi::jsc_value_new_null(context.as_ref().to_glib_none().0)) }
    }

    /// Create a new [`Value`][crate::Value] from `number`.
    /// ## `context`
    /// a [`Context`][crate::Context]
    /// ## `number`
    /// a number
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_number")]
    pub fn new_number(context: &impl IsA<Context>, number: f64) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_number(
                context.as_ref().to_glib_none().0,
                number,
            ))
        }
    }

    //#[doc(alias = "jsc_value_new_object")]
    //pub fn new_object(context: &impl IsA<Context>, instance: /*Unimplemented*/Option<Basic: Pointer>, jsc_class: Option<&Class>) -> Value {
    //    unsafe { TODO: call ffi:jsc_value_new_object() }
    //}

    /// Create a new [`Value`][crate::Value] from `string`. If you need to create a [`Value`][crate::Value] from a
    /// string containing null characters, use [`new_string_from_bytes()`][Self::new_string_from_bytes()] instead.
    /// ## `context`
    /// a [`Context`][crate::Context]
    /// ## `string`
    /// a null-terminated string
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_string")]
    pub fn new_string(context: &impl IsA<Context>, string: Option<&str>) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_string(
                context.as_ref().to_glib_none().0,
                string.to_glib_none().0,
            ))
        }
    }

    /// Create a new [`Value`][crate::Value] from `bytes`.
    /// ## `context`
    /// a [`Context`][crate::Context]
    /// ## `bytes`
    /// a [`glib::Bytes`][crate::glib::Bytes]
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_string_from_bytes")]
    pub fn new_string_from_bytes(
        context: &impl IsA<Context>,
        bytes: Option<&glib::Bytes>,
    ) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_string_from_bytes(
                context.as_ref().to_glib_none().0,
                bytes.to_glib_none().0,
            ))
        }
    }

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //#[doc(alias = "jsc_value_new_typed_array")]
    //pub fn new_typed_array(context: &impl IsA<Context>, type_: /*Ignored*/TypedArrayType, length: usize) -> Value {
    //    unsafe { TODO: call ffi:jsc_value_new_typed_array() }
    //}

    /// Create a new [`Value`][crate::Value] referencing `<function>`undefined`</function>` in `context`.
    /// ## `context`
    /// a [`Context`][crate::Context]
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value].
    #[doc(alias = "jsc_value_new_undefined")]
    pub fn new_undefined(context: &impl IsA<Context>) -> Value {
        unsafe {
            from_glib_full(ffi::jsc_value_new_undefined(
                context.as_ref().to_glib_none().0,
            ))
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Value`] objects.
    ///
    /// This method returns an instance of [`ValueBuilder`](crate::builders::ValueBuilder) which can be used to create [`Value`] objects.
    pub fn builder() -> ValueBuilder {
        ValueBuilder::default()
    }
}

impl fmt::Display for Value {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&ValueExt::to_str(self))
    }
}

#[derive(Clone, Default)]
// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Value`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct ValueBuilder {
    context: Option<Context>,
}

impl ValueBuilder {
    // rustdoc-stripper-ignore-next
    /// Create a new [`ValueBuilder`].
    pub fn new() -> Self {
        Self::default()
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Value`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Value {
        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
        if let Some(ref context) = self.context {
            properties.push(("context", context));
        }
        glib::Object::new::<Value>(&properties)
    }

    /// The [`Context`][crate::Context] in which the value was created.
    pub fn context(mut self, context: &impl IsA<Context>) -> Self {
        self.context = Some(context.clone().upcast());
        self
    }
}

/// Trait containing all [`struct@Value`] methods.
///
/// # Implementors
///
/// [`Value`][struct@crate::Value]
pub trait ValueExt: 'static {
    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //#[doc(alias = "jsc_value_array_buffer_get_data")]
    //fn array_buffer_get_data(&self, size: usize) -> /*Unimplemented*/Option<Basic: Pointer>;

    /// Gets the size in bytes of the array buffer.
    ///
    /// Obtains the size in bytes of the memory region that holds the contents of
    /// an `ArrayBuffer`.
    ///
    /// # Returns
    ///
    /// size, in bytes.
    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    #[doc(alias = "jsc_value_array_buffer_get_size")]
    fn array_buffer_get_size(&self) -> usize;

    //#[doc(alias = "jsc_value_constructor_call")]
    //#[must_use]
    //fn constructor_call(&self, first_parameter_type: glib::types::Type, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Value>;

    /// Invoke `<function>`new`</function>` with constructor referenced by `self`. If `n_parameters`
    /// is 0 no parameters will be passed to the constructor.
    /// ## `parameters`
    /// the [`Value`][crate::Value]<!-- -->s to pass as parameters to the constructor, or [`None`]
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value] referencing the newly created object instance.
    #[doc(alias = "jsc_value_constructor_callv")]
    #[must_use]
    fn constructor_callv(&self, parameters: &[Value]) -> Option<Value>;

    //#[doc(alias = "jsc_value_function_call")]
    //#[must_use]
    //fn function_call(&self, first_parameter_type: glib::types::Type, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Value>;

    /// Call function referenced by `self`, passing the given `parameters`. If `n_parameters`
    /// is 0 no parameters will be passed to the function.
    ///
    /// This function always returns a [`Value`][crate::Value], in case of void functions a [`Value`][crate::Value] referencing
    /// `<function>`undefined`</function>` is returned
    /// ## `parameters`
    /// the [`Value`][crate::Value]<!-- -->s to pass as parameters to the function, or [`None`]
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value] with the return value of the function.
    #[doc(alias = "jsc_value_function_callv")]
    #[must_use]
    fn function_callv(&self, parameters: &[Value]) -> Option<Value>;

    /// Get the [`Context`][crate::Context] in which `self` was created.
    ///
    /// # Returns
    ///
    /// the [`Value`][crate::Value] context.
    #[doc(alias = "jsc_value_get_context")]
    #[doc(alias = "get_context")]
    fn context(&self) -> Option<Context>;

    /// Get whether the value referenced by `self` is an array.
    ///
    /// # Returns
    ///
    /// whether the value is an array.
    #[doc(alias = "jsc_value_is_array")]
    fn is_array(&self) -> bool;

    /// Check whether the `self` is an `ArrayBuffer`.
    ///
    /// # Returns
    ///
    /// whether the value is an `ArrayBuffer`
    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    #[doc(alias = "jsc_value_is_array_buffer")]
    fn is_array_buffer(&self) -> bool;

    /// Get whether the value referenced by `self` is a boolean.
    ///
    /// # Returns
    ///
    /// whether the value is a boolean.
    #[doc(alias = "jsc_value_is_boolean")]
    fn is_boolean(&self) -> bool;

    /// Get whether the value referenced by `self` is a constructor.
    ///
    /// # Returns
    ///
    /// whether the value is a constructor.
    #[doc(alias = "jsc_value_is_constructor")]
    fn is_constructor(&self) -> bool;

    /// Get whether the value referenced by `self` is a function
    ///
    /// # Returns
    ///
    /// whether the value is a function.
    #[doc(alias = "jsc_value_is_function")]
    fn is_function(&self) -> bool;

    /// Get whether the value referenced by `self` is `<function>`null`</function>`.
    ///
    /// # Returns
    ///
    /// whether the value is null.
    #[doc(alias = "jsc_value_is_null")]
    fn is_null(&self) -> bool;

    /// Get whether the value referenced by `self` is a number.
    ///
    /// # Returns
    ///
    /// whether the value is a number.
    #[doc(alias = "jsc_value_is_number")]
    fn is_number(&self) -> bool;

    /// Get whether the value referenced by `self` is an object.
    ///
    /// # Returns
    ///
    /// whether the value is an object.
    #[doc(alias = "jsc_value_is_object")]
    fn is_object(&self) -> bool;

    /// Get whether the value referenced by `self` is a string
    ///
    /// # Returns
    ///
    /// whether the value is a string
    #[doc(alias = "jsc_value_is_string")]
    fn is_string(&self) -> bool;

    /// Determines whether a value is a typed array.
    ///
    /// # Returns
    ///
    /// Whether `self` is a typed array.
    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    #[doc(alias = "jsc_value_is_typed_array")]
    fn is_typed_array(&self) -> bool;

    /// Get whether the value referenced by `self` is `<function>`undefined`</function>`.
    ///
    /// # Returns
    ///
    /// whether the value is undefined.
    #[doc(alias = "jsc_value_is_undefined")]
    fn is_undefined(&self) -> bool;

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //#[doc(alias = "jsc_value_new_typed_array_with_buffer")]
    //#[must_use]
    //fn new_typed_array_with_buffer(&self, type_: /*Ignored*/TypedArrayType, offset: usize, length: isize) -> Option<Value>;

    /// Define or modify a property with `property_name` in object referenced by `self`. This is equivalent to
    /// JavaScript `<function>`Object.defineProperty()`</function>` when used with a data descriptor.
    /// ## `property_name`
    /// the name of the property to define
    /// ## `flags`
    /// [`ValuePropertyFlags`][crate::ValuePropertyFlags]
    /// ## `property_value`
    /// the default property value
    #[doc(alias = "jsc_value_object_define_property_data")]
    fn object_define_property_data(
        &self,
        property_name: &str,
        flags: ValuePropertyFlags,
        property_value: Option<&impl IsA<Value>>,
    );

    /// Try to delete property with `name` from `self`. This function will return [`false`] if
    /// the property was defined without [`ValuePropertyFlags::CONFIGURABLE`][crate::ValuePropertyFlags::CONFIGURABLE] flag.
    /// ## `name`
    /// the property name
    ///
    /// # Returns
    ///
    /// [`true`] if the property was deleted, or [`false`] otherwise.
    #[doc(alias = "jsc_value_object_delete_property")]
    fn object_delete_property(&self, name: &str) -> bool;

    /// Get the list of property names of `self`. Only properties defined with [`ValuePropertyFlags::ENUMERABLE`][crate::ValuePropertyFlags::ENUMERABLE]
    /// flag will be collected.
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array of strings containing the
    ///  property names, or [`None`] if `self` doesn't have enumerable properties. Use `g_strfreev()` to free.
    #[doc(alias = "jsc_value_object_enumerate_properties")]
    fn object_enumerate_properties(&self) -> Vec<glib::GString>;

    /// Get property with `name` from `self`.
    /// ## `name`
    /// the property name
    ///
    /// # Returns
    ///
    /// the property [`Value`][crate::Value].
    #[doc(alias = "jsc_value_object_get_property")]
    #[must_use]
    fn object_get_property(&self, name: &str) -> Option<Value>;

    /// Get property at `index` from `self`.
    /// ## `index`
    /// the property index
    ///
    /// # Returns
    ///
    /// the property [`Value`][crate::Value].
    #[doc(alias = "jsc_value_object_get_property_at_index")]
    #[must_use]
    fn object_get_property_at_index(&self, index: u32) -> Option<Value>;

    /// Get whether `self` has property with `name`.
    /// ## `name`
    /// the property name
    ///
    /// # Returns
    ///
    /// [`true`] if `self` has a property with `name`, or [`false`] otherwise
    #[doc(alias = "jsc_value_object_has_property")]
    fn object_has_property(&self, name: &str) -> bool;

    //#[doc(alias = "jsc_value_object_invoke_method")]
    //#[must_use]
    //fn object_invoke_method(&self, name: &str, first_parameter_type: glib::types::Type, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Value>;

    /// Invoke method with `name` on object referenced by `self`, passing the given `parameters`. If
    /// `n_parameters` is 0 no parameters will be passed to the method.
    /// The object instance will be handled automatically even when the method is a custom one
    /// registered with `jsc_class_add_method()`, so it should never be passed explicitly as parameter
    /// of this function.
    ///
    /// This function always returns a [`Value`][crate::Value], in case of void methods a [`Value`][crate::Value] referencing
    /// `<function>`undefined`</function>` is returned.
    /// ## `name`
    /// the method name
    /// ## `parameters`
    /// the [`Value`][crate::Value]<!-- -->s to pass as parameters to the method, or [`None`]
    ///
    /// # Returns
    ///
    /// a [`Value`][crate::Value] with the return value of the method.
    #[doc(alias = "jsc_value_object_invoke_methodv")]
    #[must_use]
    fn object_invoke_methodv(&self, name: &str, parameters: &[Value]) -> Option<Value>;

    /// Get whether the value referenced by `self` is an instance of class `name`.
    /// ## `name`
    /// a class name
    ///
    /// # Returns
    ///
    /// whether the value is an object instance of class `name`.
    #[doc(alias = "jsc_value_object_is_instance_of")]
    fn object_is_instance_of(&self, name: &str) -> bool;

    /// Set `property` with `name` on `self`.
    /// ## `name`
    /// the property name
    /// ## `property`
    /// the [`Value`][crate::Value] to set
    #[doc(alias = "jsc_value_object_set_property")]
    fn object_set_property(&self, name: &str, property: &impl IsA<Value>);

    /// Set `property` at `index` on `self`.
    /// ## `index`
    /// the property index
    /// ## `property`
    /// the [`Value`][crate::Value] to set
    #[doc(alias = "jsc_value_object_set_property_at_index")]
    fn object_set_property_at_index(&self, index: u32, property: &impl IsA<Value>);

    /// Convert `self` to a boolean.
    ///
    /// # Returns
    ///
    /// a `gboolean` result of the conversion.
    #[doc(alias = "jsc_value_to_boolean")]
    fn to_boolean(&self) -> bool;

    /// Convert `self` to a double.
    ///
    /// # Returns
    ///
    /// a `gdouble` result of the conversion.
    #[doc(alias = "jsc_value_to_double")]
    fn to_double(&self) -> f64;

    /// Convert `self` to a `gint32`.
    ///
    /// # Returns
    ///
    /// a `gint32` result of the conversion.
    #[doc(alias = "jsc_value_to_int32")]
    fn to_int32(&self) -> i32;

    /// Create a JSON string of `self` serialization. If `indent` is 0, the resulting JSON will
    /// not contain newlines. The size of the indent is clamped to 10 spaces.
    /// ## `indent`
    /// The number of spaces to indent when nesting.
    ///
    /// # Returns
    ///
    /// a null-terminated JSON string with serialization of `self`
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    #[doc(alias = "jsc_value_to_json")]
    fn to_json(&self, indent: u32) -> Option<glib::GString>;

    /// Convert `self` to a string. Use [`to_string_as_bytes()`][Self::to_string_as_bytes()] instead, if you need to
    /// handle strings containing null characters.
    ///
    /// # Returns
    ///
    /// a null-terminated string result of the conversion.
    #[doc(alias = "jsc_value_to_string")]
    #[doc(alias = "to_string")]
    fn to_str(&self) -> glib::GString;

    /// Convert `self` to a string and return the results as [`glib::Bytes`][crate::glib::Bytes]. This is needed
    /// to handle strings with null characters.
    ///
    /// # Returns
    ///
    /// a [`glib::Bytes`][crate::glib::Bytes] with the result of the conversion.
    #[doc(alias = "jsc_value_to_string_as_bytes")]
    fn to_string_as_bytes(&self) -> Option<glib::Bytes>;

    /// Obtain the `ArrayBuffer` for the memory region of the typed array elements.
    ///
    /// # Returns
    ///
    /// A [`Value`][crate::Value]
    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    #[doc(alias = "jsc_value_typed_array_get_buffer")]
    #[must_use]
    fn typed_array_get_buffer(&self) -> Option<Value>;

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //#[doc(alias = "jsc_value_typed_array_get_data")]
    //fn typed_array_get_data(&self) -> (/*Unimplemented*/Option<Basic: Pointer>, usize);

    /// Gets the number of elements in a typed array.
    ///
    /// # Returns
    ///
    /// number of elements.
    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    #[doc(alias = "jsc_value_typed_array_get_length")]
    fn typed_array_get_length(&self) -> usize;

    /// Gets the offset over the underlying array buffer data.
    ///
    /// # Returns
    ///
    /// offset, in bytes.
    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    #[doc(alias = "jsc_value_typed_array_get_offset")]
    fn typed_array_get_offset(&self) -> usize;

    /// Gets the size of a typed array.
    ///
    /// # Returns
    ///
    /// size, in bytes.
    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    #[doc(alias = "jsc_value_typed_array_get_size")]
    fn typed_array_get_size(&self) -> usize;

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //#[doc(alias = "jsc_value_typed_array_get_type")]
    //fn typed_array_get_type(&self) -> /*Ignored*/TypedArrayType;
}

impl<O: IsA<Value>> ValueExt for O {
    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //fn array_buffer_get_data(&self, size: usize) -> /*Unimplemented*/Option<Basic: Pointer> {
    //    unsafe { TODO: call ffi:jsc_value_array_buffer_get_data() }
    //}

    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    fn array_buffer_get_size(&self) -> usize {
        unsafe { ffi::jsc_value_array_buffer_get_size(self.as_ref().to_glib_none().0) }
    }

    //fn constructor_call(&self, first_parameter_type: glib::types::Type, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Value> {
    //    unsafe { TODO: call ffi:jsc_value_constructor_call() }
    //}

    fn constructor_callv(&self, parameters: &[Value]) -> Option<Value> {
        let n_parameters = parameters.len() as u32;
        unsafe {
            from_glib_full(ffi::jsc_value_constructor_callv(
                self.as_ref().to_glib_none().0,
                n_parameters,
                parameters.to_glib_none().0,
            ))
        }
    }

    //fn function_call(&self, first_parameter_type: glib::types::Type, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Value> {
    //    unsafe { TODO: call ffi:jsc_value_function_call() }
    //}

    fn function_callv(&self, parameters: &[Value]) -> Option<Value> {
        let n_parameters = parameters.len() as u32;
        unsafe {
            from_glib_full(ffi::jsc_value_function_callv(
                self.as_ref().to_glib_none().0,
                n_parameters,
                parameters.to_glib_none().0,
            ))
        }
    }

    fn context(&self) -> Option<Context> {
        unsafe { from_glib_none(ffi::jsc_value_get_context(self.as_ref().to_glib_none().0)) }
    }

    fn is_array(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_array(self.as_ref().to_glib_none().0)) }
    }

    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    fn is_array_buffer(&self) -> bool {
        unsafe {
            from_glib(ffi::jsc_value_is_array_buffer(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_boolean(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_boolean(self.as_ref().to_glib_none().0)) }
    }

    fn is_constructor(&self) -> bool {
        unsafe {
            from_glib(ffi::jsc_value_is_constructor(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_function(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_function(self.as_ref().to_glib_none().0)) }
    }

    fn is_null(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_null(self.as_ref().to_glib_none().0)) }
    }

    fn is_number(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_number(self.as_ref().to_glib_none().0)) }
    }

    fn is_object(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_object(self.as_ref().to_glib_none().0)) }
    }

    fn is_string(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_string(self.as_ref().to_glib_none().0)) }
    }

    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    fn is_typed_array(&self) -> bool {
        unsafe {
            from_glib(ffi::jsc_value_is_typed_array(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_undefined(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_is_undefined(self.as_ref().to_glib_none().0)) }
    }

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //fn new_typed_array_with_buffer(&self, type_: /*Ignored*/TypedArrayType, offset: usize, length: isize) -> Option<Value> {
    //    unsafe { TODO: call ffi:jsc_value_new_typed_array_with_buffer() }
    //}

    fn object_define_property_data(
        &self,
        property_name: &str,
        flags: ValuePropertyFlags,
        property_value: Option<&impl IsA<Value>>,
    ) {
        unsafe {
            ffi::jsc_value_object_define_property_data(
                self.as_ref().to_glib_none().0,
                property_name.to_glib_none().0,
                flags.into_glib(),
                property_value.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn object_delete_property(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::jsc_value_object_delete_property(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    fn object_enumerate_properties(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::jsc_value_object_enumerate_properties(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn object_get_property(&self, name: &str) -> Option<Value> {
        unsafe {
            from_glib_full(ffi::jsc_value_object_get_property(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    fn object_get_property_at_index(&self, index: u32) -> Option<Value> {
        unsafe {
            from_glib_full(ffi::jsc_value_object_get_property_at_index(
                self.as_ref().to_glib_none().0,
                index,
            ))
        }
    }

    fn object_has_property(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::jsc_value_object_has_property(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    //fn object_invoke_method(&self, name: &str, first_parameter_type: glib::types::Type, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Value> {
    //    unsafe { TODO: call ffi:jsc_value_object_invoke_method() }
    //}

    fn object_invoke_methodv(&self, name: &str, parameters: &[Value]) -> Option<Value> {
        let n_parameters = parameters.len() as u32;
        unsafe {
            from_glib_full(ffi::jsc_value_object_invoke_methodv(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                n_parameters,
                parameters.to_glib_none().0,
            ))
        }
    }

    fn object_is_instance_of(&self, name: &str) -> bool {
        unsafe {
            from_glib(ffi::jsc_value_object_is_instance_of(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    fn object_set_property(&self, name: &str, property: &impl IsA<Value>) {
        unsafe {
            ffi::jsc_value_object_set_property(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
                property.as_ref().to_glib_none().0,
            );
        }
    }

    fn object_set_property_at_index(&self, index: u32, property: &impl IsA<Value>) {
        unsafe {
            ffi::jsc_value_object_set_property_at_index(
                self.as_ref().to_glib_none().0,
                index,
                property.as_ref().to_glib_none().0,
            );
        }
    }

    fn to_boolean(&self) -> bool {
        unsafe { from_glib(ffi::jsc_value_to_boolean(self.as_ref().to_glib_none().0)) }
    }

    fn to_double(&self) -> f64 {
        unsafe { ffi::jsc_value_to_double(self.as_ref().to_glib_none().0) }
    }

    fn to_int32(&self) -> i32 {
        unsafe { ffi::jsc_value_to_int32(self.as_ref().to_glib_none().0) }
    }

    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    fn to_json(&self, indent: u32) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::jsc_value_to_json(
                self.as_ref().to_glib_none().0,
                indent,
            ))
        }
    }

    fn to_str(&self) -> glib::GString {
        unsafe { from_glib_full(ffi::jsc_value_to_string(self.as_ref().to_glib_none().0)) }
    }

    fn to_string_as_bytes(&self) -> Option<glib::Bytes> {
        unsafe {
            from_glib_full(ffi::jsc_value_to_string_as_bytes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    fn typed_array_get_buffer(&self) -> Option<Value> {
        unsafe {
            from_glib_full(ffi::jsc_value_typed_array_get_buffer(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //fn typed_array_get_data(&self) -> (/*Unimplemented*/Option<Basic: Pointer>, usize) {
    //    unsafe { TODO: call ffi:jsc_value_typed_array_get_data() }
    //}

    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    fn typed_array_get_length(&self) -> usize {
        unsafe { ffi::jsc_value_typed_array_get_length(self.as_ref().to_glib_none().0) }
    }

    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    fn typed_array_get_offset(&self) -> usize {
        unsafe { ffi::jsc_value_typed_array_get_offset(self.as_ref().to_glib_none().0) }
    }

    #[cfg(any(feature = "v2_38", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    fn typed_array_get_size(&self) -> usize {
        unsafe { ffi::jsc_value_typed_array_get_size(self.as_ref().to_glib_none().0) }
    }

    //#[cfg(any(feature = "v2_38", feature = "dox"))]
    //#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_38")))]
    //fn typed_array_get_type(&self) -> /*Ignored*/TypedArrayType {
    //    unsafe { TODO: call ffi:jsc_value_typed_array_get_type() }
    //}
}