qt_qml/

lib.rs

#![cfg_attr(feature = "ritual_rustdoc_nightly", feature(doc_cfg))]
//! This crate was generated by `ritual`.
//!                     See [README](https://github.com/rust-qt/ritual) for more information.

mod __ffi {
    //! Functions provided by the C++ wrapper library

    include!(concat!(env!("OUT_DIR"), "/ffi.rs"));
}
pub mod ops;
pub use ::cpp_core;
pub use ::qt_core;
pub use ::qt_gui;
pub mod q_v4;
pub mod q_j_s_value {
    //! C++ type: <span style='color: green;'>```QJSValue```</span>

    /// <p>This enum is used to specify a single-valued type.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QJSValue::SpecialValue```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#SpecialValue-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This enum is used to specify a single-valued type.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct SpecialValue(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for SpecialValue {
        fn from(value: ::std::os::raw::c_int) -> Self {
            SpecialValue(value)
        }
    }

    impl From<SpecialValue> for ::std::os::raw::c_int {
        fn from(value: SpecialValue) -> Self {
            value.0
        }
    }

    impl SpecialValue {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl SpecialValue {
        /// A null value. (C++ enum variant: <span style='color: green;'>```NullValue = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const NullValue: crate::q_j_s_value::SpecialValue = crate::q_j_s_value::SpecialValue(0);
        /// An undefined value. (C++ enum variant: <span style='color: green;'>```UndefinedValue = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const UndefinedValue: crate::q_j_s_value::SpecialValue =
            crate::q_j_s_value::SpecialValue(1);
    }

    /// <p>Use this enum for JavaScript language-specific types of Error objects.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QJSValue::ErrorType```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#ErrorType-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Use this enum for JavaScript language-specific types of Error objects.</p>
    /// <p>They may be useful when emulating language features in C++ requires the use of specialized exception types. In addition, they may help to more clearly communicate certain typical conditions, instead of throwing a generic JavaScript exception. For example, code that deals with networking and resource locators may find it useful to propagate errors related to malformed locators using the URIError type.</p>
    ///
    /// <p>This enum was introduced or modified in  Qt 5.12.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct ErrorType(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for ErrorType {
        fn from(value: ::std::os::raw::c_int) -> Self {
            ErrorType(value)
        }
    }

    impl From<ErrorType> for ::std::os::raw::c_int {
        fn from(value: ErrorType) -> Self {
            value.0
        }
    }

    impl ErrorType {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl ErrorType {
        /// C++ enum variant: <span style='color: green;'>```NoError = 0```</span>
        #[allow(non_upper_case_globals)]
        pub const NoError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(0);
        /// A generic Error object, but not of a specific sub-type. (C++ enum variant: <span style='color: green;'>```GenericError = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const GenericError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(1);
        /// C++ enum variant: <span style='color: green;'>```EvalError = 2```</span>
        #[allow(non_upper_case_globals)]
        pub const EvalError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(2);
        /// A value did not match the expected set or range. (C++ enum variant: <span style='color: green;'>```RangeError = 3```</span>)
        #[allow(non_upper_case_globals)]
        pub const RangeError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(3);
        /// A non-existing variable referenced. (C++ enum variant: <span style='color: green;'>```ReferenceError = 4```</span>)
        #[allow(non_upper_case_globals)]
        pub const ReferenceError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(4);
        /// An invalid token or sequence of tokens was encountered that does not conform with the syntax of the language. (C++ enum variant: <span style='color: green;'>```SyntaxError = 5```</span>)
        #[allow(non_upper_case_globals)]
        pub const SyntaxError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(5);
        /// An operand or argument is incompatible with the type expected. (C++ enum variant: <span style='color: green;'>```TypeError = 6```</span>)
        #[allow(non_upper_case_globals)]
        pub const TypeError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(6);
        /// A URI handling function was used incorrectly or the URI provided is malformed. (C++ enum variant: <span style='color: green;'>```URIError = 7```</span>)
        #[allow(non_upper_case_globals)]
        pub const URIError: crate::q_j_s_value::ErrorType = crate::q_j_s_value::ErrorType(7);
    }
}
/// <p><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> supports the types defined in the <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> standard: The primitive types, which are Undefined, Null, Boolean, Number, and String; and the Object and Array types. Additionally, built-in support is provided for Qt/C++ types such as <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> and <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
///
/// C++ class: <span style='color: green;'>```QJSValue```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qjsvalue.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> supports the types defined in the <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> standard: The primitive types, which are Undefined, Null, Boolean, Number, and String; and the Object and Array types. Additionally, built-in support is provided for Qt/C++ types such as <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> and <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
/// <p>For the object-based types (including Date and RegExp), use the newT() functions in <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> (e.g. <a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">QJSEngine::newObject</a>()) to create a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> of the desired type. For the primitive types, use one of the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> constructor overloads. For other types, e.g. registered gadget types such as <a href="http://doc.qt.io/qt-5/qpoint.html">QPoint</a>, you can use <a href="http://doc.qt.io/qt-5/qjsengine.html#toScriptValue">QJSEngine::toScriptValue</a>.</p>
/// <p>The methods named isT() (e.g. <a href="http://doc.qt.io/qt-5/qjsvalue.html#isBool">isBool</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#isUndefined">isUndefined</a>()) can be used to test if a value is of a certain type. The methods named toT() (e.g. <a href="http://doc.qt.io/qt-5/qjsvalue.html#toBool">toBool</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>()) can be used to convert a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> to another type. You can also use the generic qjsvalue_cast() function.</p>
/// <p>Object values have zero or more properties which are themselves QJSValues. Use <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty">setProperty</a>() to set a property of an object, and call <a href="http://doc.qt.io/qt-5/qjsvalue.html#property">property</a>() to retrieve the value of a property.</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a></span> myEngine;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue">QJSValue</a></span> myObject <span class="operator">=</span> myEngine<span class="operator">.</span>newObject();
///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue">QJSValue</a></span> myOtherObject <span class="operator">=</span> myEngine<span class="operator">.</span>newObject();
///   myObject<span class="operator">.</span>setProperty(<span class="string">"myChild"</span><span class="operator">,</span> myOtherObject);
///   myObject<span class="operator">.</span>setProperty(<span class="string">"name"</span><span class="operator">,</span> <span class="string">"John Doe"</span>);
///
/// </pre>
/// <p>If you want to iterate over the properties of a script object, use the <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a> class.</p>
/// <p>Object values have an internal <code>prototype</code> property, which can be accessed with <a href="http://doc.qt.io/qt-5/qjsvalue.html#prototype">prototype</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#setPrototype">setPrototype</a>().</p>
/// <p>Function objects (objects for which <a href="http://doc.qt.io/qt-5/qjsvalue.html#isCallable">isCallable</a>()) returns true) can be invoked by calling <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>(). Constructor functions can be used to construct new objects by calling <a href="http://doc.qt.io/qt-5/qjsvalue.html#callAsConstructor">callAsConstructor</a>().</p>
/// <p>Use <a href="http://doc.qt.io/qt-5/qjsvalue.html#equals">equals</a>() or <a href="http://doc.qt.io/qt-5/qjsvalue.html#strictlyEquals">strictlyEquals</a>() to compare a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> to another.</p>
/// <p>Note that a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> for which <a href="http://doc.qt.io/qt-5/qjsvalue.html#isObject">isObject</a>() is true only carries a reference to an actual object; copying the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> will only copy the object reference, not the object itself. If you want to clone an object (i.e. copy an object's properties to another object), you can do so with the help of a <code>for-in</code> statement in script code, or <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a> in C++.</p>
/// <a name="working-with-arrays"></a></div>
#[repr(C)]
pub struct QJSValue {
    _unused: u8,
}
impl QJSValue {
    /// <p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, passing <i>args</i> as arguments to the function, and using the globalObject() as the "this"-object. Returns the value returned from the function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::call(const QList<QJSValue>& args = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, passing <i>args</i> as arguments to the function, and using the globalObject() as the "this"-object. Returns the value returned from the function.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not callable, call() does nothing and returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>Calling call() can cause an exception to occur in the script engine; in that case, call() returns the value that was thrown (typically an <code>Error</code> object). You can call <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">isError</a>() on the return value to determine whether an exception occurred.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isCallable">isCallable</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#callWithInstance">callWithInstance</a>(), and <a href="http://doc.qt.io/qt-5/qjsvalue.html#callAsConstructor">callAsConstructor</a>().</p></div>
    #[inline(always)]
    pub unsafe fn call_1a(
        &self,
        args: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_call(
                self as *const crate::QJSValue as *mut crate::QJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(args)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, passing <i>args</i> as arguments to the function, and using the globalObject() as the "this"-object. Returns the value returned from the function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::call()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, passing <i>args</i> as arguments to the function, and using the globalObject() as the "this"-object. Returns the value returned from the function.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not callable, call() does nothing and returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>Calling call() can cause an exception to occur in the script engine; in that case, call() returns the value that was thrown (typically an <code>Error</code> object). You can call <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">isError</a>() on the return value to determine whether an exception occurred.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isCallable">isCallable</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#callWithInstance">callWithInstance</a>(), and <a href="http://doc.qt.io/qt-5/qjsvalue.html#callAsConstructor">callAsConstructor</a>().</p></div>
    #[inline(always)]
    pub unsafe fn call_0a(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_call1(
                self as *const crate::QJSValue as *mut crate::QJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a new <code>Object</code> and calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a constructor, using the created object as the `this' object and passing <i>args</i> as arguments. If the return value from the constructor call is an object, then that object is returned; otherwise the default constructed object is returned.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::callAsConstructor(const QList<QJSValue>& args = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#callAsConstructor">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a new <code>Object</code> and calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a constructor, using the created object as the `this' object and passing <i>args</i> as arguments. If the return value from the constructor call is an object, then that object is returned; otherwise the default constructed object is returned.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not a function, callAsConstructor() does nothing and returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>Calling this function can cause an exception to occur in the script engine; in that case, the value that was thrown (typically an <code>Error</code> object) is returned. You can call <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">isError</a>() on the return value to determine whether an exception occurred.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() and <a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">QJSEngine::newObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn call_as_constructor_1a(
        &self,
        args: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_callAsConstructor(
                self as *const crate::QJSValue as *mut crate::QJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(args)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a new <code>Object</code> and calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a constructor, using the created object as the `this' object and passing <i>args</i> as arguments. If the return value from the constructor call is an object, then that object is returned; otherwise the default constructed object is returned.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::callAsConstructor()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#callAsConstructor">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a new <code>Object</code> and calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a constructor, using the created object as the `this' object and passing <i>args</i> as arguments. If the return value from the constructor call is an object, then that object is returned; otherwise the default constructed object is returned.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not a function, callAsConstructor() does nothing and returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>Calling this function can cause an exception to occur in the script engine; in that case, the value that was thrown (typically an <code>Error</code> object) is returned. You can call <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">isError</a>() on the return value to determine whether an exception occurred.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() and <a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">QJSEngine::newObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn call_as_constructor_0a(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_callAsConstructor1(
                self as *const crate::QJSValue as *mut crate::QJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, using <i>instance</i> as the `this' object in the function call, and passing <i>args</i> as arguments to the function. Returns the value returned from the function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::callWithInstance(const QJSValue& instance, const QList<QJSValue>& args = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#callWithInstance">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, using <i>instance</i> as the `this' object in the function call, and passing <i>args</i> as arguments to the function. Returns the value returned from the function.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not a function, <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() does nothing and returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>Note that if <i>instance</i> is not an object, the global object (see <a href="http://doc.qt.io/qt-5/qjsengine.html#globalObject">QJSEngine::globalObject</a>()) will be used as the `this' object.</p>
    /// <p>Calling <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() can cause an exception to occur in the script engine; in that case, <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() returns the value that was thrown (typically an <code>Error</code> object). You can call <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">isError</a>() on the return value to determine whether an exception occurred.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>().</p></div>
    #[inline(always)]
    pub unsafe fn call_with_instance_2a(
        &self,
        instance: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
        args: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_callWithInstance(
                self as *const crate::QJSValue as *mut crate::QJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(instance)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(args)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, using <i>instance</i> as the `this' object in the function call, and passing <i>args</i> as arguments to the function. Returns the value returned from the function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::callWithInstance(const QJSValue& instance)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#callWithInstance">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Calls this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as a function, using <i>instance</i> as the `this' object in the function call, and passing <i>args</i> as arguments to the function. Returns the value returned from the function.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not a function, <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() does nothing and returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>Note that if <i>instance</i> is not an object, the global object (see <a href="http://doc.qt.io/qt-5/qjsengine.html#globalObject">QJSEngine::globalObject</a>()) will be used as the `this' object.</p>
    /// <p>Calling <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() can cause an exception to occur in the script engine; in that case, <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>() returns the value that was thrown (typically an <code>Error</code> object). You can call <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">isError</a>() on the return value to determine whether an exception occurred.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>().</p></div>
    #[inline(always)]
    pub unsafe fn call_with_instance_1a(
        &self,
        instance: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_callWithInstance1(
                self as *const crate::QJSValue as *mut crate::QJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(instance)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Assigns the <i>other</i> value to this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue& QJSValue::operator=(const QJSValue& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#operator-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns the <i>other</i> value to this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>Note that if <i>other</i> is an object (<a href="http://doc.qt.io/qt-5/qjsvalue.html#isObject">isObject</a>() returns true), only a reference to the underlying object will be assigned; the object itself will not be copied.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_operator_1(
                self as *const crate::QJSValue as *mut crate::QJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(other)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Attempts to delete this object's property of the given <i>name</i>. Returns true if the property was deleted, otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::deleteProperty(const QString& name)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#deleteProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Attempts to delete this object's property of the given <i>name</i>. Returns true if the property was deleted, otherwise returns false.</p>
    /// <p>The behavior of this function is consistent with the JavaScript delete operator. In particular:</p>
    /// <ul>
    /// <li>Non-configurable properties cannot be deleted.</li>
    /// <li>This function will return true even if this object doesn't have a property of the given <i>name</i> (i.e., non-existent properties are "trivially deletable").</li>
    /// <li>If this object doesn't have an own property of the given <i>name</i>, but an object in the <a href="http://doc.qt.io/qt-5/qjsvalue.html#prototype">prototype</a>() chain does, the prototype object's property is not deleted, and this function returns true.</li>
    /// </ul>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty">setProperty</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#hasOwnProperty">hasOwnProperty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn delete_property(
        &self,
        name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_deleteProperty(
            self as *const crate::QJSValue as *mut crate::QJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(name)
                .as_raw_ptr(),
        )
    }

    /// <p>This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSEngine* QJSValue::engine() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue-obsolete.html#engine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.</p>
    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> that created this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, or 0 if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is invalid or the value is not associated with a particular engine.</p></div>
    #[inline(always)]
    pub unsafe fn engine(&self) -> ::qt_core::QPtr<crate::QJSEngine> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSValue_engine(self as *const crate::QJSValue) };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is equal to <i>other</i>, otherwise returns false. The comparison follows the behavior described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 11.9.3, "The Abstract Equality Comparison Algorithm".</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::equals(const QJSValue& other) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#equals">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is equal to <i>other</i>, otherwise returns false. The comparison follows the behavior described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 11.9.3, "The Abstract Equality Comparison Algorithm".</p>
    /// <p>This function can return true even if the type of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is different from the type of the <i>other</i> value; i.e. the comparison is not strict. For example, comparing the number 9 to the string "9" returns true; comparing an undefined value to a null value returns true; comparing a <code>Number</code> object whose primitive value is 6 to a <code>String</code> object whose primitive value is "6" returns true; and comparing the number 1 to the boolean value <code>true</code> returns true. If you want to perform a comparison without such implicit value conversion, use <a href="http://doc.qt.io/qt-5/qjsvalue.html#strictlyEquals">strictlyEquals</a>().</p>
    /// <p>Note that if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> or the <i>other</i> value are objects, calling this function has side effects on the script engine, since the engine will call the object's valueOf() function (and possibly <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>()) in an attempt to convert the object to a primitive value (possibly resulting in an uncaught script exception).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#strictlyEquals">strictlyEquals</a>().</p></div>
    #[inline(always)]
    pub unsafe fn equals(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_equals(
            self as *const crate::QJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(other).as_raw_ptr(),
        )
    }

    /// <p>Returns the error type this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> represents if it is an Error object. Otherwise, returns <code>NoError."</code></p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue::ErrorType QJSValue::errorType() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#errorType">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the error type this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> represents if it is an Error object. Otherwise, returns <code>NoError."</code></p>
    /// <p>This function was introduced in  Qt 5.12.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">isError</a>() and <a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">QJSEngine - Script Exceptions</a>.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn error_type(&self) -> crate::q_j_s_value::ErrorType {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_errorType(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this object has an own (not prototype-inherited) property of the given <i>name</i>, otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::hasOwnProperty(const QString& name) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#hasOwnProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this object has an own (not prototype-inherited) property of the given <i>name</i>, otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#property">property</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#hasProperty">hasProperty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn has_own_property(
        &self,
        name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_hasOwnProperty(
            self as *const crate::QJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(name)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns true if this object has a property of the given <i>name</i>, otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::hasProperty(const QString& name) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#hasProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this object has a property of the given <i>name</i>, otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#property">property</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#hasOwnProperty">hasOwnProperty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn has_property(
        &self,
        name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_hasProperty(
            self as *const crate::QJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(name)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the Array class; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isArray() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isArray">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the Array class; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newArray">QJSEngine::newArray</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_array(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isArray(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Boolean; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isBool() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isBool">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Boolean; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toBool">toBool</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_bool(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isBool(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> can be called a function, otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isCallable() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isCallable">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> can be called a function, otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_callable(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isCallable(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the Date class; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isDate() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isDate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the Date class; otherwise returns false.</p></div>
    #[inline(always)]
    pub unsafe fn is_date(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isDate(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the Error class; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isError() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the Error class; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#errorType">errorType</a>() and <a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">QJSEngine - Script Exceptions</a>.</p></div>
    #[inline(always)]
    pub unsafe fn is_error(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isError(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Null; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isNull() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isNull">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Null; otherwise returns false.</p></div>
    #[inline(always)]
    pub unsafe fn is_null(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isNull(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Number; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isNumber() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isNumber">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Number; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toNumber">toNumber</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_number(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isNumber(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the Object type; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the Object type; otherwise returns false.</p>
    /// <p>Note that function values, variant values, and <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> values are objects, so this function returns true for such values.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">QJSEngine::newObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_object(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isObject(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a>; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isQMetaObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isQMetaObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a>; otherwise returns false.</p>
    /// <p>This function was introduced in  Qt 5.8.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toQMetaObject">toQMetaObject</a>() and <a href="http://doc.qt.io/qt-5/qjsengine.html#newQMetaObject-1">QJSEngine::newQMetaObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_q_meta_object(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isQMetaObject(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isQObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isQObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>; otherwise returns false.</p>
    /// <p>Note: This function returns true even if the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> that this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> wraps has been deleted.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toQObject">toQObject</a>() and <a href="http://doc.qt.io/qt-5/qjsengine.html#newQObject">QJSEngine::newQObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_q_object(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isQObject(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the RegExp class; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isRegExp() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isRegExp">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object of the RegExp class; otherwise returns false.</p></div>
    #[inline(always)]
    pub unsafe fn is_reg_exp(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isRegExp(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type String; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isString() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isString">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type String; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_string(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isString(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Undefined; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isUndefined() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isUndefined">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is of the primitive type Undefined; otherwise returns false.</p></div>
    #[inline(always)]
    pub unsafe fn is_undefined(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isUndefined(self as *const crate::QJSValue)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a variant value; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::isVariant() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#isVariant">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a variant value; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toVariant">toVariant</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_variant(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_isVariant(self as *const crate::QJSValue)
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a special <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(QJSValue::SpecialValue value = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a special <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_special_value(
        value: crate::q_j_s_value::SpecialValue,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue(value) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a boolean <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(bool value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-3">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a boolean <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_bool(value: bool) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue3(value) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a number <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(int value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-4">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a number <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_int(value: ::std::os::raw::c_int) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue4(value) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a number <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(unsigned int value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-5">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a number <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_uint(value: ::std::os::raw::c_uint) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue5(value) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a number <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(double value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-6">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a number <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_double(
        value: ::std::os::raw::c_double,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue6(value) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a string <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(const QString& value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-7">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a string <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_string(
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue7(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(value)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a string <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(const QLatin1String& value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-8">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a string <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_latin1_string(
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QLatin1String>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue8(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QLatin1String>>::cast_into(value)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a string <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(const char* str)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-9">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> with a string <i>value</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_char(
        str: *const ::std::os::raw::c_char,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue9(str) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> supports the types defined in the <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> standard: The primitive types, which are Undefined, Null, Boolean, Number, and String; and the Object and Array types. Additionally, built-in support is provided for Qt/C++ types such as <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> and <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> supports the types defined in the <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> standard: The primitive types, which are Undefined, Null, Boolean, Number, and String; and the Object and Array types. Additionally, built-in support is provided for Qt/C++ types such as <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> and <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    /// <p>For the object-based types (including Date and RegExp), use the newT() functions in <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> (e.g. <a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">QJSEngine::newObject</a>()) to create a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> of the desired type. For the primitive types, use one of the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> constructor overloads. For other types, e.g. registered gadget types such as <a href="http://doc.qt.io/qt-5/qpoint.html">QPoint</a>, you can use <a href="http://doc.qt.io/qt-5/qjsengine.html#toScriptValue">QJSEngine::toScriptValue</a>.</p>
    /// <p>The methods named isT() (e.g. <a href="http://doc.qt.io/qt-5/qjsvalue.html#isBool">isBool</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#isUndefined">isUndefined</a>()) can be used to test if a value is of a certain type. The methods named toT() (e.g. <a href="http://doc.qt.io/qt-5/qjsvalue.html#toBool">toBool</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>()) can be used to convert a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> to another type. You can also use the generic qjsvalue_cast() function.</p>
    /// <p>Object values have zero or more properties which are themselves QJSValues. Use <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty">setProperty</a>() to set a property of an object, and call <a href="http://doc.qt.io/qt-5/qjsvalue.html#property">property</a>() to retrieve the value of a property.</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a></span> myEngine;
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue">QJSValue</a></span> myObject <span class="operator">=</span> myEngine<span class="operator">.</span>newObject();
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue">QJSValue</a></span> myOtherObject <span class="operator">=</span> myEngine<span class="operator">.</span>newObject();
    ///   myObject<span class="operator">.</span>setProperty(<span class="string">"myChild"</span><span class="operator">,</span> myOtherObject);
    ///   myObject<span class="operator">.</span>setProperty(<span class="string">"name"</span><span class="operator">,</span> <span class="string">"John Doe"</span>);
    ///
    /// </pre>
    /// <p>If you want to iterate over the properties of a script object, use the <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a> class.</p>
    /// <p>Object values have an internal <code>prototype</code> property, which can be accessed with <a href="http://doc.qt.io/qt-5/qjsvalue.html#prototype">prototype</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#setPrototype">setPrototype</a>().</p>
    /// <p>Function objects (objects for which <a href="http://doc.qt.io/qt-5/qjsvalue.html#isCallable">isCallable</a>()) returns true) can be invoked by calling <a href="http://doc.qt.io/qt-5/qjsvalue.html#call">call</a>(). Constructor functions can be used to construct new objects by calling <a href="http://doc.qt.io/qt-5/qjsvalue.html#callAsConstructor">callAsConstructor</a>().</p>
    /// <p>Use <a href="http://doc.qt.io/qt-5/qjsvalue.html#equals">equals</a>() or <a href="http://doc.qt.io/qt-5/qjsvalue.html#strictlyEquals">strictlyEquals</a>() to compare a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> to another.</p>
    /// <p>Note that a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> for which <a href="http://doc.qt.io/qt-5/qjsvalue.html#isObject">isObject</a>() is true only carries a reference to an actual object; copying the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> will only copy the object reference, not the object itself. If you want to clone an object (i.e. copy an object's properties to another object), you can do so with the help of a <code>for-in</code> statement in script code, or <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a> in C++.</p>
    /// <a name="working-with-arrays"></a></div>
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue11() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> that is a copy of <i>other</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValue::QJSValue(const QJSValue& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#QJSValue-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a new <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> that is a copy of <i>other</i>.</p>
    /// <p>Note that if <i>other</i> is an object (i.e., <a href="http://doc.qt.io/qt-5/qjsvalue.html#isObject">isObject</a>() would return true), then only a reference to the underlying object is copied into the new script value (i.e., the object itself is not copied).</p></div>
    #[inline(always)]
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_QJSValue1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(other)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>'s property with the given <i>name</i>. If no such property exists, an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is returned.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::property(const QString& name) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#property">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>'s property with the given <i>name</i>. If no such property exists, an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is returned.</p>
    /// <p>If the property is implemented using a getter function (i.e. has the PropertyGetter flag set), calling property() has side-effects on the script engine, since the getter function will be called (possibly resulting in an uncaught script exception). If an exception occurred, property() returns the value that was thrown (typically an <code>Error</code> object).</p>
    /// <p>To access array elements, use the <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty-1">setProperty(quint32 arrayIndex, const QJSValue &amp;value)</a> overload instead.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty">setProperty</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#hasProperty">hasProperty</a>(), and <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a>.</p></div>
    #[inline(always)]
    pub unsafe fn property_q_string(
        &self,
        name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_property(
                self as *const crate::QJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(name)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::property(quint32 arrayIndex) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#property-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Returns the property at the given <i>arrayIndex</i>.</p>
    /// <p>It is possible to access elements in an array in two ways. The first is to use the array index as the property name:</p>
    /// <pre class="cpp">
    ///
    ///   <a href="http://doc.qt.io/qt-5/#qDebug">qDebug</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> jsValueArray<span class="operator">.</span>property(QLatin1String(<span class="string">"4"</span>))<span class="operator">.</span>toString();
    ///
    /// </pre>
    /// <p>The second is to use the overload that takes an index:</p>
    /// <pre class="cpp">
    ///
    ///   <a href="http://doc.qt.io/qt-5/#qDebug">qDebug</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> jsValueArray<span class="operator">.</span>property(<span class="number">4</span>)<span class="operator">.</span>toString();
    ///
    /// </pre>
    /// <p>Both of these approaches achieve the same result, except that the latter:</p>
    /// <ul>
    /// <li>Is easier to use (can use an integer directly)</li>
    /// <li>Is faster (no conversion to integer)</li>
    /// </ul>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not an Array object, this function behaves as if <a href="http://doc.qt.io/qt-5/qjsvalue.html#property">property</a>() was called with the string representation of <i>arrayIndex</i>.</p></div>
    #[inline(always)]
    pub unsafe fn property_u32(&self, array_index: u32) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValue_property1(
                self as *const crate::QJSValue,
                array_index,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, returns the internal prototype (<code>__proto__</code> property) of this object; otherwise returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValue::prototype() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#prototype">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, returns the internal prototype (<code>__proto__</code> property) of this object; otherwise returns an undefined <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#setPrototype">setPrototype</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#isObject">isObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn prototype(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSValue_prototype(self as *const crate::QJSValue) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Sets the value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>'s property with the given <i>name</i> to the given <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSValue::setProperty(const QString& name, const QJSValue& value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>'s property with the given <i>name</i> to the given <i>value</i>.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not an object, this function does nothing.</p>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> does not already have a property with name <i>name</i>, a new property is created.</p>
    /// <p>To modify array elements, use the <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty-1">setProperty(quint32 arrayIndex, const QJSValue &amp;value)</a> overload instead.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#property">property</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#deleteProperty">deleteProperty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_property_q_string_q_j_s_value(
        &self,
        name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_setProperty(
            self as *const crate::QJSValue as *mut crate::QJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(name)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(value).as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSValue::setProperty(quint32 arrayIndex, const QJSValue& value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Sets the property at the given <i>arrayIndex</i> to the given <i>value</i>.</p>
    /// <p>It is possible to modify elements in an array in two ways. The first is to use the array index as the property name:</p>
    /// <pre class="cpp">
    ///
    ///   jsValueArray<span class="operator">.</span>setProperty(QLatin1String(<span class="string">"4"</span>)<span class="operator">,</span> value);
    ///
    /// </pre>
    /// <p>The second is to use the overload that takes an index:</p>
    /// <pre class="cpp">
    ///
    ///   jsValueArray<span class="operator">.</span>setProperty(<span class="number">4</span><span class="operator">,</span> value);
    ///
    /// </pre>
    /// <p>Both of these approaches achieve the same result, except that the latter:</p>
    /// <ul>
    /// <li>Is easier to use (can use an integer directly)</li>
    /// <li>Is faster (no conversion to integer)</li>
    /// </ul>
    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not an Array object, this function behaves as if <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty">setProperty</a>() was called with the string representation of <i>arrayIndex</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#property-1">property</a>(quint32 arrayIndex) and <a href="http://doc.qt.io/qt-5/qjsvalue.html#working-with-arrays">Working With Arrays</a>.</p></div>
    #[inline(always)]
    pub unsafe fn set_property_u32_q_j_s_value(
        &self,
        array_index: u32,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_setProperty1(
            self as *const crate::QJSValue as *mut crate::QJSValue,
            array_index,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(value).as_raw_ptr(),
        )
    }

    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, sets the internal prototype (<code>__proto__</code> property) of this object to be <i>prototype</i>; if the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is null, it sets the prototype to null; otherwise does nothing.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSValue::setPrototype(const QJSValue& prototype)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#setPrototype">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, sets the internal prototype (<code>__proto__</code> property) of this object to be <i>prototype</i>; if the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is null, it sets the prototype to null; otherwise does nothing.</p>
    /// <p>The internal prototype should not be confused with the public property with name "prototype"; the public prototype is usually only set on functions that act as constructors.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#prototype">prototype</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#isObject">isObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_prototype(
        &self,
        prototype: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_setPrototype(
            self as *const crate::QJSValue as *mut crate::QJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(prototype)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is equal to <i>other</i> using strict comparison (no conversion), otherwise returns false. The comparison follows the behavior described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 11.9.6, "The Strict Equality Comparison Algorithm".</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::strictlyEquals(const QJSValue& other) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#strictlyEquals">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is equal to <i>other</i> using strict comparison (no conversion), otherwise returns false. The comparison follows the behavior described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 11.9.6, "The Strict Equality Comparison Algorithm".</p>
    /// <p>If the type of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is different from the type of the <i>other</i> value, this function returns false. If the types are equal, the result depends on the type, as shown in the following table:</p>
    /// <div class="table"><table class="generic">
    ///  <thead><tr class="qt-style"><th>Type</th><th>Result</th></tr></thead>
    /// <tbody><tr valign="top" class="odd"><td>Undefined</td><td>true</td></tr>
    /// <tr valign="top" class="even"><td>Null</td><td>true</td></tr>
    /// <tr valign="top" class="odd"><td>Boolean</td><td>true if both values are true, false otherwise</td></tr>
    /// <tr valign="top" class="even"><td>Number</td><td>false if either value is NaN (Not-a-Number); true if values are equal, false otherwise</td></tr>
    /// <tr valign="top" class="odd"><td>String</td><td>true if both values are exactly the same sequence of characters, false otherwise</td></tr>
    /// <tr valign="top" class="even"><td>Object</td><td>true if both values refer to the same object, false otherwise</td></tr>
    /// </tbody></table></div>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#equals">equals</a>().</p></div>
    #[inline(always)]
    pub unsafe fn strictly_equals(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_strictlyEquals(
            self as *const crate::QJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(other).as_raw_ptr(),
        )
    }

    /// <p>Returns the boolean value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, using the conversion rules described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.2, "ToBoolean".</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValue::toBool() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toBool">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the boolean value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, using the conversion rules described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.2, "ToBoolean".</p>
    /// <p>Note that if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, calling this function has side effects on the script engine, since the engine will call the object's valueOf() function (and possibly <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>()) in an attempt to convert the object to a primitive value (possibly resulting in an uncaught script exception).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isBool">isBool</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_bool(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_toBool(self as *const crate::QJSValue)
    }

    /// <p>Returns a <a href="http://doc.qt.io/qt-5/qdatetime.html">QDateTime</a> representation of this value, in local time. If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not a date, or the value of the date is NaN (Not-a-Number), an invalid <a href="http://doc.qt.io/qt-5/qdatetime.html">QDateTime</a> is returned.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QDateTime QJSValue::toDateTime() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toDateTime">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a <a href="http://doc.qt.io/qt-5/qdatetime.html">QDateTime</a> representation of this value, in local time. If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is not a date, or the value of the date is NaN (Not-a-Number), an invalid <a href="http://doc.qt.io/qt-5/qdatetime.html">QDateTime</a> is returned.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isDate">isDate</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_date_time(&self) -> ::cpp_core::CppBox<::qt_core::QDateTime> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSValue_toDateTime(self as *const crate::QJSValue) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the signed 32-bit integer value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, using the conversion rules described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.5, "ToInt32".</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```qint32 QJSValue::toInt() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toInt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the signed 32-bit integer value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, using the conversion rules described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.5, "ToInt32".</p>
    /// <p>Note that if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, calling this function has side effects on the script engine, since the engine will call the object's valueOf() function (and possibly <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>()) in an attempt to convert the object to a primitive value (possibly resulting in an uncaught script exception).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toNumber">toNumber</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#toUInt">toUInt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_int(&self) -> i32 {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_toInt(self as *const crate::QJSValue)
    }

    /// <p>Returns the number value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, as defined in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.3, "ToNumber".</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```double QJSValue::toNumber() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toNumber">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, as defined in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.3, "ToNumber".</p>
    /// <p>Note that if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, calling this function has side effects on the script engine, since the engine will call the object's valueOf() function (and possibly <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>()) in an attempt to convert the object to a primitive value (possibly resulting in an uncaught script exception).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isNumber">isNumber</a>(), <a href="http://doc.qt.io/qt-5/qjsvalue.html#toInt">toInt</a>(), and <a href="http://doc.qt.io/qt-5/qjsvalue.html#toUInt">toUInt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_number(&self) -> ::std::os::raw::c_double {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_toNumber(self as *const crate::QJSValue)
    }

    /// <p>* If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a>, returns the <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> pointer * that the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> represents; otherwise, returns <code>nullptr</code>. * *</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QMetaObject* QJSValue::toQMetaObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toQMetaObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>* If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a>, returns the <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> pointer * that the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> represents; otherwise, returns <code>nullptr</code>. * *</p>
    /// <p>This function was introduced in  Qt 5.8.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isQMetaObject">isQMetaObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_q_meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSValue_toQMetaObject(self as *const crate::QJSValue) };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, returns the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> pointer that the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> represents; otherwise, returns <code>nullptr</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QJSValue::toQObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toQObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>If this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, returns the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> pointer that the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> represents; otherwise, returns <code>nullptr</code>.</p>
    /// <p>If the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> that this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> wraps has been deleted, this function returns <code>nullptr</code> (i.e. it is possible for toQObject() to return <code>nullptr</code> even when <a href="http://doc.qt.io/qt-5/qjsvalue.html#isQObject">isQObject</a>() returns true).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isQObject">isQObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_q_object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSValue_toQObject(self as *const crate::QJSValue) };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns the string value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, as defined in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.8, "ToString".</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QJSValue::toString() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the string value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, as defined in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.8, "ToString".</p>
    /// <p>Note that if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, calling this function has side effects on the script engine, since the engine will call the object's toString() function (and possibly valueOf()) in an attempt to convert the object to a primitive value (possibly resulting in an uncaught script exception).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isString">isString</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_string(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSValue_toString(self as *const crate::QJSValue) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the unsigned 32-bit integer value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, using the conversion rules described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.6, "ToUint32".</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```quint32 QJSValue::toUInt() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toUInt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the unsigned 32-bit integer value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, using the conversion rules described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a> section 9.6, "ToUint32".</p>
    /// <p>Note that if this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> is an object, calling this function has side effects on the script engine, since the engine will call the object's valueOf() function (and possibly <a href="http://doc.qt.io/qt-5/qjsvalue.html#toString">toString</a>()) in an attempt to convert the object to a primitive value (possibly resulting in an uncaught script exception).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toNumber">toNumber</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#toInt">toInt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_u_int(&self) -> u32 {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_toUInt(self as *const crate::QJSValue)
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, if it can be converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>; otherwise returns an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>. The conversion is performed according to the following table:</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant QJSValue::toVariant() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#toVariant">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> value of this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>, if it can be converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>; otherwise returns an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>. The conversion is performed according to the following table:</p>
    /// <div class="table"><table class="generic">
    ///  <thead><tr class="qt-style"><th>Input Type</th><th>Result</th></tr></thead>
    /// <tbody><tr valign="top" class="odd"><td>Undefined</td><td>An invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</td></tr>
    /// <tr valign="top" class="even"><td>Null</td><td>A <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> containing a null pointer (<a href="http://doc.qt.io/qt-5/qmetatype.html#Type-enum">QMetaType::Nullptr</a>).</td></tr>
    /// <tr valign="top" class="odd"><td>Boolean</td><td>A <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> containing the value of the boolean.</td></tr>
    /// <tr valign="top" class="even"><td>Number</td><td>A <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> containing the value of the number.</td></tr>
    /// <tr valign="top" class="odd"><td>String</td><td>A <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> containing the value of the string.</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> Object</td><td>The result is the <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> value of the object (no conversion).</td></tr>
    /// <tr valign="top" class="odd"><td><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> Object</td><td>A <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> containing a pointer to the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</td></tr>
    /// <tr valign="top" class="even"><td>Date Object</td><td>A <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> containing the date value (<a href="http://doc.qt.io/qt-5/qjsvalue.html#toDateTime">toDateTime</a>()).</td></tr>
    /// <tr valign="top" class="odd"><td>RegExp Object</td><td>A <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> containing the regular expression value.</td></tr>
    /// <tr valign="top" class="even"><td>Array Object</td><td>The array is converted to a <a href="http://doc.qt.io/qt-5/qvariant.html#QVariantList-typedef">QVariantList</a>. Each element is converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>, recursively; cyclic references are not followed.</td></tr>
    /// <tr valign="top" class="odd"><td>Object</td><td>The object is converted to a <a href="http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef">QVariantMap</a>. Each property is converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>, recursively; cyclic references are not followed.</td></tr>
    /// </tbody></table></div>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#isVariant">isVariant</a>().</p></div>
    #[inline(always)]
    pub unsafe fn to_variant(&self) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSValue_toVariant(self as *const crate::QJSValue) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_qml_debugging_enabler {
    //! C++ type: <span style='color: green;'>```QQmlDebuggingEnabler```</span>

    /// <p>Defines the debug connector's start behavior. You can interrupt QML engines starting while a debug client is connecting, in order to set breakpoints in or profile startup code.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlDebuggingEnabler::StartMode```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#StartMode-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Defines the debug connector's start behavior. You can interrupt QML engines starting while a debug client is connecting, in order to set breakpoints in or profile startup code.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct StartMode(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for StartMode {
        fn from(value: ::std::os::raw::c_int) -> Self {
            StartMode(value)
        }
    }

    impl From<StartMode> for ::std::os::raw::c_int {
        fn from(value: StartMode) -> Self {
            value.0
        }
    }

    impl StartMode {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl StartMode {
        /// Run any QML engines as usual while the debug services are connecting. (C++ enum variant: <span style='color: green;'>```DoNotWaitForClient = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const DoNotWaitForClient: crate::q_qml_debugging_enabler::StartMode =
            crate::q_qml_debugging_enabler::StartMode(0);
        /// If a QML engine starts while the debug services are connecting, interrupt it until they are done. (C++ enum variant: <span style='color: green;'>```WaitForClient = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const WaitForClient: crate::q_qml_debugging_enabler::StartMode =
            crate::q_qml_debugging_enabler::StartMode(1);
    }
}
/// C++ class: <span style='color: green;'>```QQmlDebuggingEnabler```</span>.
#[repr(C)]
pub struct QQmlDebuggingEnabler {
    _unused: u8,
}
impl QQmlDebuggingEnabler {
    /// <p>Enables debugging for QML engines created after calling this function. The debug connector will connect to a debugger waiting on a local socket at the given <i>socketFileName</i> and block the QML engine until the connection is established if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it will not block. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlDebuggingEnabler::connectToLocalDebugger(const QString& socketFileName, QQmlDebuggingEnabler::StartMode mode = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#connectToLocalDebugger">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables debugging for QML engines created after calling this function. The debug connector will connect to a debugger waiting on a local socket at the given <i>socketFileName</i> and block the QML engine until the connection is established if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it will not block. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    /// <p>This function was introduced in  Qt 5.6.</p></div>
    #[inline(always)]
    pub unsafe fn connect_to_local_debugger_2a(
        socket_file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        mode: crate::q_qml_debugging_enabler::StartMode,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_connectToLocalDebugger(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(
                socket_file_name,
            )
            .as_raw_ptr(),
            mode,
        )
    }

    /// <p>Enables debugging for QML engines created after calling this function. The debug connector will connect to a debugger waiting on a local socket at the given <i>socketFileName</i> and block the QML engine until the connection is established if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it will not block. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlDebuggingEnabler::connectToLocalDebugger(const QString& socketFileName)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#connectToLocalDebugger">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables debugging for QML engines created after calling this function. The debug connector will connect to a debugger waiting on a local socket at the given <i>socketFileName</i> and block the QML engine until the connection is established if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it will not block. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    /// <p>This function was introduced in  Qt 5.6.</p></div>
    #[inline(always)]
    pub unsafe fn connect_to_local_debugger_1a(
        socket_file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_connectToLocalDebugger1(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(
                socket_file_name,
            )
            .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlDebuggingEnabler& QQmlDebuggingEnabler::operator=(const QQmlDebuggingEnabler& other)```</span>.
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlDebuggingEnabler>>,
    ) -> ::cpp_core::Ref<crate::QQmlDebuggingEnabler> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_operator_(
                self as *const crate::QQmlDebuggingEnabler as *mut crate::QQmlDebuggingEnabler,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlDebuggingEnabler>>::cast_into(
                    other,
                )
                .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Retrieves the plugin keys of the debugger services provided by default. The debugger services enable a debug client to use a Qml/JavaScript debugger, in order to set breakpoints, pause execution, evaluate expressions and similar debugging tasks. Returns List of plugin keys of default debugger services.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QStringList QQmlDebuggingEnabler::debuggerServices()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#debuggerServices">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Retrieves the plugin keys of the debugger services provided by default. The debugger services enable a debug client to use a Qml/JavaScript debugger, in order to set breakpoints, pause execution, evaluate expressions and similar debugging tasks. Returns List of plugin keys of default debugger services.</p></div>
    #[inline(always)]
    pub unsafe fn debugger_services() -> ::cpp_core::CppBox<::qt_core::QStringList> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_debuggerServices() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Retrieves the plugin keys of the inspector services provided by default. The inspector services enable a debug client to use a visual inspector tool for Qt Quick. Returns List of plugin keys of default inspector services.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QStringList QQmlDebuggingEnabler::inspectorServices()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#inspectorServices">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Retrieves the plugin keys of the inspector services provided by default. The inspector services enable a debug client to use a visual inspector tool for Qt Quick. Returns List of plugin keys of default inspector services.</p></div>
    #[inline(always)]
    pub unsafe fn inspector_services() -> ::cpp_core::CppBox<::qt_core::QStringList> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_inspectorServices() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Retrieves the plugin keys of the debug services designed to be used with a native debugger. The native debugger will communicate with these services by directly reading and writing the application's memory. Returns List of plugin keys of debug services designed to be used with a native debugger.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QStringList QQmlDebuggingEnabler::nativeDebuggerServices()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#nativeDebuggerServices">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Retrieves the plugin keys of the debug services designed to be used with a native debugger. The native debugger will communicate with these services by directly reading and writing the application's memory. Returns List of plugin keys of debug services designed to be used with a native debugger.</p></div>
    #[inline(always)]
    pub unsafe fn native_debugger_services() -> ::cpp_core::CppBox<::qt_core::QStringList> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_nativeDebuggerServices() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlDebuggingEnabler::QQmlDebuggingEnabler(bool printWarning = …)```</span>.
    #[inline(always)]
    pub unsafe fn new_1a(print_warning: bool) -> ::cpp_core::CppBox<crate::QQmlDebuggingEnabler> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_QQmlDebuggingEnabler(print_warning)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlDebuggingEnabler::QQmlDebuggingEnabler()```</span>.
    #[inline(always)]
    pub unsafe fn new_0a() -> ::cpp_core::CppBox<crate::QQmlDebuggingEnabler> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_QQmlDebuggingEnabler1() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlDebuggingEnabler::QQmlDebuggingEnabler(const QQmlDebuggingEnabler& other)```</span>.
    #[inline(always)]
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlDebuggingEnabler>>,
    ) -> ::cpp_core::CppBox<crate::QQmlDebuggingEnabler> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_QQmlDebuggingEnabler2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlDebuggingEnabler>>::cast_into(
                    other,
                )
                .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Retrieves the names of the profiler services provided by default. The profiler services enable a debug client to use a profiler and track the time taken by various QML and JavaScript constructs, as well as the <a href="http://doc.qt.io/qt-5/qtquick-qmlmodule.html">QtQuick</a> SceneGraph. Returns List of plugin keys of default profiler services.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QStringList QQmlDebuggingEnabler::profilerServices()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#profilerServices">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Retrieves the names of the profiler services provided by default. The profiler services enable a debug client to use a profiler and track the time taken by various QML and JavaScript constructs, as well as the <a href="http://doc.qt.io/qt-5/qtquick-qmlmodule.html">QtQuick</a> SceneGraph. Returns List of plugin keys of default profiler services.</p></div>
    #[inline(always)]
    pub unsafe fn profiler_services() -> ::cpp_core::CppBox<::qt_core::QStringList> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_profilerServices() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Restricts the services available from the debug connector. The connector will scan plugins in the "qmltooling" subdirectory of the default plugin path. If this function is not called before the debug connector is enabled, all services found that way will be available to any client. If this function is called, only the services with plugin keys given in <i>services</i> will be available.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static void QQmlDebuggingEnabler::setServices(const QStringList& services)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#setServices">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Restricts the services available from the debug connector. The connector will scan plugins in the "qmltooling" subdirectory of the default plugin path. If this function is not called before the debug connector is enabled, all services found that way will be available to any client. If this function is called, only the services with plugin keys given in <i>services</i> will be available.</p>
    /// <p>Use this method to disable debugger and inspector services when profiling to get better performance and more realistic profiles. The debugger service will put any JavaScript engine it connects to into interpreted mode, disabling the JIT compiler.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#debuggerServices">debuggerServices</a>(), <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#profilerServices">profilerServices</a>(), and <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#inspectorServices">inspectorServices</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_services(
        services: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QStringList>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_setServices(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QStringList>>::cast_into(services)
                .as_raw_ptr(),
        )
    }

    /// <p>Enables debugging for QML engines created after calling this function. A debug connector plugin specified by <i>pluginName</i> will be loaded and started using the given <i>configuration</i>. Supported configuration entries and their semantics depend on the plugin being loaded. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlDebuggingEnabler::startDebugConnector(const QString& pluginName, const QHash<QString, QVariant>& configuration = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#startDebugConnector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables debugging for QML engines created after calling this function. A debug connector plugin specified by <i>pluginName</i> will be loaded and started using the given <i>configuration</i>. Supported configuration entries and their semantics depend on the plugin being loaded. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    /// <p>This function was introduced in  Qt 5.7.</p></div>
    #[inline(always)]
    pub unsafe fn start_debug_connector_2a(
        plugin_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        configuration: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QHashOfQStringQVariant>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_startDebugConnector(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(plugin_name)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QHashOfQStringQVariant>>::cast_into(
                configuration,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>Enables debugging for QML engines created after calling this function. A debug connector plugin specified by <i>pluginName</i> will be loaded and started using the given <i>configuration</i>. Supported configuration entries and their semantics depend on the plugin being loaded. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlDebuggingEnabler::startDebugConnector(const QString& pluginName)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#startDebugConnector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables debugging for QML engines created after calling this function. A debug connector plugin specified by <i>pluginName</i> will be loaded and started using the given <i>configuration</i>. Supported configuration entries and their semantics depend on the plugin being loaded. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    /// <p>This function was introduced in  Qt 5.7.</p></div>
    #[inline(always)]
    pub unsafe fn start_debug_connector_1a(
        plugin_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_startDebugConnector1(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(plugin_name)
                .as_raw_ptr(),
        )
    }

    /// <p>Enables debugging for QML engines created after calling this function. The debug connector will listen on <i>port</i> at <i>hostName</i> and block the QML engine until it receives a connection if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it won't block and if <i>hostName</i> is not specified it will listen on all available interfaces. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlDebuggingEnabler::startTcpDebugServer(int port, QQmlDebuggingEnabler::StartMode mode = …, const QString& hostName = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#startTcpDebugServer">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables debugging for QML engines created after calling this function. The debug connector will listen on <i>port</i> at <i>hostName</i> and block the QML engine until it receives a connection if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it won't block and if <i>hostName</i> is not specified it will listen on all available interfaces. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p></div>
    #[inline(always)]
    pub unsafe fn start_tcp_debug_server_3a(
        port: ::std::os::raw::c_int,
        mode: crate::q_qml_debugging_enabler::StartMode,
        host_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_startTcpDebugServer(
            port,
            mode,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(host_name)
                .as_raw_ptr(),
        )
    }

    /// <p>Enables debugging for QML engines created after calling this function. The debug connector will listen on <i>port</i> at <i>hostName</i> and block the QML engine until it receives a connection if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it won't block and if <i>hostName</i> is not specified it will listen on all available interfaces. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlDebuggingEnabler::startTcpDebugServer(int port, QQmlDebuggingEnabler::StartMode mode = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#startTcpDebugServer">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables debugging for QML engines created after calling this function. The debug connector will listen on <i>port</i> at <i>hostName</i> and block the QML engine until it receives a connection if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it won't block and if <i>hostName</i> is not specified it will listen on all available interfaces. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p></div>
    #[inline(always)]
    pub unsafe fn start_tcp_debug_server_2a(
        port: ::std::os::raw::c_int,
        mode: crate::q_qml_debugging_enabler::StartMode,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_startTcpDebugServer1(port, mode)
    }

    /// <p>Enables debugging for QML engines created after calling this function. The debug connector will listen on <i>port</i> at <i>hostName</i> and block the QML engine until it receives a connection if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it won't block and if <i>hostName</i> is not specified it will listen on all available interfaces. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlDebuggingEnabler::startTcpDebugServer(int port)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmldebuggingenabler.html#startTcpDebugServer">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Enables debugging for QML engines created after calling this function. The debug connector will listen on <i>port</i> at <i>hostName</i> and block the QML engine until it receives a connection if <i>mode</i> is <code>WaitForClient</code>. If <i>mode</i> is not specified it won't block and if <i>hostName</i> is not specified it will listen on all available interfaces. You can only start one debug connector at a time. A debug connector may have already been started if the -qmljsdebugger= command line argument was given. This method returns <code>true</code> if a new debug connector was successfully started, or <code>false</code> otherwise.</p></div>
    #[inline(always)]
    pub unsafe fn start_tcp_debug_server_1a(port: ::std::os::raw::c_int) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_startTcpDebugServer2(port)
    }
}

pub mod q_j_s_engine {
    //! C++ type: <span style='color: green;'>```QJSEngine```</span>

    /// <p>This enum is used to specify extensions to be installed via <a href="http://doc.qt.io/qt-5/qjsengine.html#installExtensions">installExtensions</a>().</p>
    ///
    /// C++ enum: <span style='color: green;'>```QJSEngine::Extension```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#Extension-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This enum is used to specify extensions to be installed via <a href="http://doc.qt.io/qt-5/qjsengine.html#installExtensions">installExtensions</a>().</p>
    ///
    /// <p><b>TranslationExtension</b></p>
    /// <p>The relation between script translation functions and C++ translation functions is described in the following table:</p>
    /// <div class="table"><table class="generic">
    ///  <thead><tr class="qt-style"><th>Script Function</th><th>Corresponding C++ Function</th></tr></thead>
    /// <tbody><tr valign="top" class="odd"><td>qsTr()</td><td><a href="http://doc.qt.io/qt-5/qobject.html#tr">QObject::tr</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TR_NOOP">QT_TR_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TR_NOOP">QT_TR_NOOP</a>()</td></tr>
    /// <tr valign="top" class="odd"><td>qsTranslate()</td><td><a href="http://doc.qt.io/qt-5/qcoreapplication.html#translate">QCoreApplication::translate</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TRANSLATE_NOOP">QT_TRANSLATE_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TRANSLATE_NOOP">QT_TRANSLATE_NOOP</a>()</td></tr>
    /// <tr valign="top" class="odd"><td>qsTrId()</td><td><a href="http://doc.qt.io/qt-5/#qtTrId">qtTrId</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TRID_NOOP">QT_TRID_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TRID_NOOP">QT_TRID_NOOP</a>()</td></tr>
    /// </tbody></table></div>
    /// <p>This flag also adds an <code>arg()</code> function to the string prototype.</p>
    /// <p>For more information, see the <a href="http://doc.qt.io/qt-5/internationalization.html">Internationalization with Qt</a> documentation.</p>
    /// <p><b>ConsoleExtension</b></p>
    /// <p>The <a href="http://doc.qt.io/qt-5/qtquick-debugging.html#console-api">console</a> object implements a subset of the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Console">Console API</a>, which provides familiar logging functions, such as <code>console.log()</code>.</p>
    /// <p>The list of functions added is as follows:</p>
    /// <ul>
    /// <li><code>console.assert()</code></li>
    /// <li><code>console.debug()</code></li>
    /// <li><code>console.exception()</code></li>
    /// <li><code>console.info()</code></li>
    /// <li><code>console.log()</code> (equivalent to <code>console.debug()</code>)</li>
    /// <li><code>console.error()</code></li>
    /// <li><code>console.time()</code></li>
    /// <li><code>console.timeEnd()</code></li>
    /// <li><code>console.trace()</code></li>
    /// <li><code>console.count()</code></li>
    /// <li><code>console.warn()</code></li>
    /// <li><code>print()</code> (equivalent to <code>console.debug()</code>)</li>
    /// </ul>
    /// <p>For more information, see the <a href="http://doc.qt.io/qt-5/qtquick-debugging.html#console-api">Console API</a> documentation.</p>
    /// <p><b>GarbageCollectionExtension</b></p>
    /// <p>The <code>gc()</code> function is equivalent to calling <a href="http://doc.qt.io/qt-5/qjsengine.html#collectGarbage">collectGarbage</a>().</p>
    /// <p>The Extensions type is a typedef for <a href="http://doc.qt.io/qt-5/qflags.html">QFlags</a>&lt;Extension&gt;. It stores an OR combination of Extension values.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Extension(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for Extension {
        fn from(value: ::std::os::raw::c_int) -> Self {
            Extension(value)
        }
    }

    impl From<Extension> for ::std::os::raw::c_int {
        fn from(value: Extension) -> Self {
            value.0
        }
    }

    impl Extension {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl Extension {
        /// Indicates that translation functions (<code>qsTr()</code>, for example) should be installed. (C++ enum variant: <span style='color: green;'>```TranslationExtension = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const TranslationExtension: crate::q_j_s_engine::Extension =
            crate::q_j_s_engine::Extension(1);
        /// Indicates that console functions (<code>console.log()</code>, for example) should be installed. (C++ enum variant: <span style='color: green;'>```ConsoleExtension = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const ConsoleExtension: crate::q_j_s_engine::Extension =
            crate::q_j_s_engine::Extension(2);
        /// Indicates that garbage collection functions (<code>gc()</code>, for example) should be installed. (C++ enum variant: <span style='color: green;'>```GarbageCollectionExtension = 4```</span>)
        #[allow(non_upper_case_globals)]
        pub const GarbageCollectionExtension: crate::q_j_s_engine::Extension =
            crate::q_j_s_engine::Extension(4);
        /// Indicates that all extension should be installed. (C++ enum variant: <span style='color: green;'>```AllExtensions = -1```</span>)
        #[allow(non_upper_case_globals)]
        pub const AllExtensions: crate::q_j_s_engine::Extension =
            crate::q_j_s_engine::Extension(-1);
    }

    impl From<crate::q_j_s_engine::Extension> for ::qt_core::QFlags<crate::q_j_s_engine::Extension> {
        fn from(value: crate::q_j_s_engine::Extension) -> Self {
            Self::from(value.to_int())
        }
    }

    impl<T: Into<::qt_core::QFlags<crate::q_j_s_engine::Extension>>> std::ops::BitOr<T>
        for crate::q_j_s_engine::Extension
    {
        type Output = ::qt_core::QFlags<crate::q_j_s_engine::Extension>;
        fn bitor(self, rhs: T) -> ::qt_core::QFlags<crate::q_j_s_engine::Extension> {
            Into::<::qt_core::QFlags<crate::q_j_s_engine::Extension>>::into(self) | rhs
        }
    }
}
/// <a name="evaluating-scripts"></a>
///
/// C++ class: <span style='color: green;'>```QJSEngine```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qjsengine.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><a name="evaluating-scripts"></a></div>
#[repr(C)]
pub struct QJSEngine {
    _unused: u8,
}
impl QJSEngine {
    /// <p>Runs the garbage collector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::collectGarbage()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#collectGarbage">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Runs the garbage collector.</p>
    /// <p>The garbage collector will attempt to reclaim memory by locating and disposing of objects that are no longer reachable in the script environment.</p>
    /// <p>Normally you don't need to call this function; the garbage collector will automatically be invoked when the <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> decides that it's wise to do so (i.e. when a certain number of new objects have been created). However, you can call this function to explicitly request that garbage collection should be performed as soon as possible.</p></div>
    #[inline(always)]
    pub unsafe fn collect_garbage(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_collectGarbage(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
        )
    }

    /// <p>Evaluates <i>program</i>, using <i>lineNumber</i> as the base line number, and returns the result of the evaluation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::evaluate(const QString& program, const QString& fileName = …, int lineNumber = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#evaluate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Evaluates <i>program</i>, using <i>lineNumber</i> as the base line number, and returns the result of the evaluation.</p>
    /// <p>The script code will be evaluated in the context of the global object.</p>
    /// <p>The evaluation of <i>program</i> can cause an <a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">exception</a> in the engine; in this case the return value will be the exception that was thrown (typically an <code>Error</code> object; see <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>()).</p>
    /// <p><i>lineNumber</i> is used to specify a starting line number for <i>program</i>; line number information reported by the engine that pertains to this evaluation will be based on this argument. For example, if <i>program</i> consists of two lines of code, and the statement on the second line causes a script exception, the exception line number would be <i>lineNumber</i> plus one. When no starting line number is specified, line numbers will be 1-based.</p>
    /// <p><i>fileName</i> is used for error reporting. For example, in error objects the file name is accessible through the "fileName" property if it is provided with this function.</p>
    /// <p><b>Note: </b>If an exception was thrown and the exception value is not an Error instance (i.e., <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>() returns <code>false</code>), the exception value will still be returned, but there is currently no API for detecting that an exception did occur in this case.</p></div>
    #[inline(always)]
    pub unsafe fn evaluate_3a(
        &self,
        program: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        line_number: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_evaluate(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(program)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                    .as_raw_ptr(),
                line_number,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Evaluates <i>program</i>, using <i>lineNumber</i> as the base line number, and returns the result of the evaluation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::evaluate(const QString& program, const QString& fileName = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#evaluate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Evaluates <i>program</i>, using <i>lineNumber</i> as the base line number, and returns the result of the evaluation.</p>
    /// <p>The script code will be evaluated in the context of the global object.</p>
    /// <p>The evaluation of <i>program</i> can cause an <a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">exception</a> in the engine; in this case the return value will be the exception that was thrown (typically an <code>Error</code> object; see <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>()).</p>
    /// <p><i>lineNumber</i> is used to specify a starting line number for <i>program</i>; line number information reported by the engine that pertains to this evaluation will be based on this argument. For example, if <i>program</i> consists of two lines of code, and the statement on the second line causes a script exception, the exception line number would be <i>lineNumber</i> plus one. When no starting line number is specified, line numbers will be 1-based.</p>
    /// <p><i>fileName</i> is used for error reporting. For example, in error objects the file name is accessible through the "fileName" property if it is provided with this function.</p>
    /// <p><b>Note: </b>If an exception was thrown and the exception value is not an Error instance (i.e., <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>() returns <code>false</code>), the exception value will still be returned, but there is currently no API for detecting that an exception did occur in this case.</p></div>
    #[inline(always)]
    pub unsafe fn evaluate_2a(
        &self,
        program: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_evaluate1(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(program)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Evaluates <i>program</i>, using <i>lineNumber</i> as the base line number, and returns the result of the evaluation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::evaluate(const QString& program)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#evaluate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Evaluates <i>program</i>, using <i>lineNumber</i> as the base line number, and returns the result of the evaluation.</p>
    /// <p>The script code will be evaluated in the context of the global object.</p>
    /// <p>The evaluation of <i>program</i> can cause an <a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">exception</a> in the engine; in this case the return value will be the exception that was thrown (typically an <code>Error</code> object; see <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>()).</p>
    /// <p><i>lineNumber</i> is used to specify a starting line number for <i>program</i>; line number information reported by the engine that pertains to this evaluation will be based on this argument. For example, if <i>program</i> consists of two lines of code, and the statement on the second line causes a script exception, the exception line number would be <i>lineNumber</i> plus one. When no starting line number is specified, line numbers will be 1-based.</p>
    /// <p><i>fileName</i> is used for error reporting. For example, in error objects the file name is accessible through the "fileName" property if it is provided with this function.</p>
    /// <p><b>Note: </b>If an exception was thrown and the exception value is not an Error instance (i.e., <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>() returns <code>false</code>), the exception value will still be returned, but there is currently no API for detecting that an exception did occur in this case.</p></div>
    #[inline(always)]
    pub unsafe fn evaluate_1a(
        &self,
        program: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_evaluate2(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(program)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns this engine's Global Object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::globalObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#globalObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns this engine's Global Object.</p>
    /// <p>By default, the Global Object contains the built-in objects that are part of <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a>, such as Math, Date and String. Additionally, you can set properties of the Global Object to make your own extensions available to all script code. Non-local variables in script code will be created as properties of the Global Object, as well as local variables in global code.</p></div>
    #[inline(always)]
    pub unsafe fn global_object(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_globalObject(self as *const crate::QJSEngine)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Imports the module located at <i>fileName</i> and returns a module namespace object that contains all exported variables, constants and functions as properties.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::importModule(const QString& fileName)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#importModule">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Imports the module located at <i>fileName</i> and returns a module namespace object that contains all exported variables, constants and functions as properties.</p>
    /// <p>If this is the first time the module is imported in the engine, the file is loaded from the specified location in either the local file system or the Qt resource system and evaluated as an ECMAScript module. The file is expected to be encoded in UTF-8 text.</p>
    /// <p>Subsequent imports of the same module will return the previously imported instance. Modules are singletons and remain around until the engine is destroyed.</p>
    /// <p>The specified <i>fileName</i> will internally be normalized using <a href="http://doc.qt.io/qt-5/qfileinfo.html#canonicalFilePath">QFileInfo::canonicalFilePath</a>(). That means that multiple imports of the same file on disk using different relative paths will load the file only once.</p>
    /// <p><b>Note: </b>If an exception is thrown during the loading of the module, the return value will be the exception (typically an <code>Error</code> object; see <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>()).</p><p>This function was introduced in  Qt 5.12.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn import_module(
        &self,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_importModule(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Installs JavaScript <i>extensions</i> to add functionality that is not available in a standard ECMAScript implementation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::installExtensions(QFlags<QJSEngine::Extension> extensions, const QJSValue& object = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#installExtensions">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Installs JavaScript <i>extensions</i> to add functionality that is not available in a standard ECMAScript implementation.</p>
    /// <p>The extensions are installed on the given <i>object</i>, or on the <a href="http://doc.qt.io/qt-5/qjsengine.html#globalObject">Global Object</a> if no object is specified.</p>
    /// <p>Several extensions can be installed at once by <code>OR</code>-ing the enum values:</p>
    /// <pre class="cpp">
    ///
    ///   installExtensions(<span class="type"><a href="http://doc.qt.io/qt-5/qjsengine.html#QJSEngine">QJSEngine</a></span><span class="operator">::</span>TranslationExtension <span class="operator">|</span> <span class="type"><a href="http://doc.qt.io/qt-5/qjsengine.html#QJSEngine">QJSEngine</a></span><span class="operator">::</span>ConsoleExtension);
    ///
    /// </pre>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#Extension-enum">Extension</a>.</p></div>
    #[inline(always)]
    pub unsafe fn install_extensions_2a(
        &self,
        extensions: ::qt_core::QFlags<crate::q_j_s_engine::Extension>,
        object: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_installExtensions(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            extensions.to_int(),
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(object)
                .as_raw_ptr(),
        )
    }

    /// <p>Installs JavaScript <i>extensions</i> to add functionality that is not available in a standard ECMAScript implementation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::installExtensions(QFlags<QJSEngine::Extension> extensions)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#installExtensions">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Installs JavaScript <i>extensions</i> to add functionality that is not available in a standard ECMAScript implementation.</p>
    /// <p>The extensions are installed on the given <i>object</i>, or on the <a href="http://doc.qt.io/qt-5/qjsengine.html#globalObject">Global Object</a> if no object is specified.</p>
    /// <p>Several extensions can be installed at once by <code>OR</code>-ing the enum values:</p>
    /// <pre class="cpp">
    ///
    ///   installExtensions(<span class="type"><a href="http://doc.qt.io/qt-5/qjsengine.html#QJSEngine">QJSEngine</a></span><span class="operator">::</span>TranslationExtension <span class="operator">|</span> <span class="type"><a href="http://doc.qt.io/qt-5/qjsengine.html#QJSEngine">QJSEngine</a></span><span class="operator">::</span>ConsoleExtension);
    ///
    /// </pre>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#Extension-enum">Extension</a>.</p></div>
    #[inline(always)]
    pub unsafe fn install_extensions_1a(
        &self,
        extensions: ::qt_core::QFlags<crate::q_j_s_engine::Extension>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_installExtensions1(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            extensions.to_int(),
        )
    }

    /// <p>This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::installTranslatorFunctions(const QJSValue& object = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine-obsolete.html#installTranslatorFunctions">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.</p>
    /// <p>Installs translator functions on the given <i>object</i>, or on the Global Object if no object is specified.</p>
    /// <p>The relation between script translator functions and C++ translator functions is described in the following table:</p>
    /// <div class="table"><table class="generic">
    ///  <thead><tr class="qt-style"><th>Script Function</th><th>Corresponding C++ Function</th></tr></thead>
    /// <tbody><tr valign="top" class="odd"><td>qsTr()</td><td><a href="http://doc.qt.io/qt-5/qobject.html#tr">QObject::tr</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TR_NOOP">QT_TR_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TR_NOOP">QT_TR_NOOP</a>()</td></tr>
    /// <tr valign="top" class="odd"><td>qsTranslate()</td><td><a href="http://doc.qt.io/qt-5/qcoreapplication.html#translate">QCoreApplication::translate</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TRANSLATE_NOOP">QT_TRANSLATE_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TRANSLATE_NOOP">QT_TRANSLATE_NOOP</a>()</td></tr>
    /// <tr valign="top" class="odd"><td>qsTrId()</td><td><a href="http://doc.qt.io/qt-5/#qtTrId">qtTrId</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TRID_NOOP">QT_TRID_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TRID_NOOP">QT_TRID_NOOP</a>()</td></tr>
    /// </tbody></table></div>
    /// <p>It also adds an arg() method to the string prototype.</p>
    /// <p>This function was introduced in  Qt 5.4.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/internationalization.html">Internationalization with Qt</a>.</p></div>
    #[inline(always)]
    pub unsafe fn install_translator_functions_1a(
        &self,
        object: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_installTranslatorFunctions(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(object)
                .as_raw_ptr(),
        )
    }

    /// <p>This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::installTranslatorFunctions()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine-obsolete.html#installTranslatorFunctions">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.</p>
    /// <p>Installs translator functions on the given <i>object</i>, or on the Global Object if no object is specified.</p>
    /// <p>The relation between script translator functions and C++ translator functions is described in the following table:</p>
    /// <div class="table"><table class="generic">
    ///  <thead><tr class="qt-style"><th>Script Function</th><th>Corresponding C++ Function</th></tr></thead>
    /// <tbody><tr valign="top" class="odd"><td>qsTr()</td><td><a href="http://doc.qt.io/qt-5/qobject.html#tr">QObject::tr</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TR_NOOP">QT_TR_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TR_NOOP">QT_TR_NOOP</a>()</td></tr>
    /// <tr valign="top" class="odd"><td>qsTranslate()</td><td><a href="http://doc.qt.io/qt-5/qcoreapplication.html#translate">QCoreApplication::translate</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TRANSLATE_NOOP">QT_TRANSLATE_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TRANSLATE_NOOP">QT_TRANSLATE_NOOP</a>()</td></tr>
    /// <tr valign="top" class="odd"><td>qsTrId()</td><td><a href="http://doc.qt.io/qt-5/#qtTrId">qtTrId</a>()</td></tr>
    /// <tr valign="top" class="even"><td><a href="http://doc.qt.io/qt-5/#QT_TRID_NOOP">QT_TRID_NOOP</a>()</td><td><a href="http://doc.qt.io/qt-5/#QT_TRID_NOOP">QT_TRID_NOOP</a>()</td></tr>
    /// </tbody></table></div>
    /// <p>It also adds an arg() method to the string prototype.</p>
    /// <p>This function was introduced in  Qt 5.4.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/internationalization.html">Internationalization with Qt</a>.</p></div>
    #[inline(always)]
    pub unsafe fn install_translator_functions_0a(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_installTranslatorFunctions1(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
        )
    }

    /// <p>Returns whether JavaScript execution is currently interrupted.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSEngine::isInterrupted() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#isInterrupted">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns whether JavaScript execution is currently interrupted.</p>
    /// <p>This function was introduced in  Qt 5.14.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#setInterrupted">setInterrupted</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(cpp_lib_version = "5.14.0"))
    )]
    #[cfg(any(cpp_lib_version = "5.14.0", feature = "ritual_rustdoc"))]
    pub unsafe fn is_interrupted(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_isInterrupted(self as *const crate::QJSEngine)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QJSEngine::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QJSEngine_metaObject(self as *const crate::QJSEngine) };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Constructs a <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSEngine::QJSEngine()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#QJSEngine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> object.</p>
    /// <p>The <a href="http://doc.qt.io/qt-5/qjsengine.html#globalObject">globalObject</a>() is initialized to have properties as described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a>, Section 15.1.</p></div>
    #[inline(always)]
    pub unsafe fn new_0a() -> ::qt_core::QBox<crate::QJSEngine> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSEngine_QJSEngine() };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Constructs a <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> object with the given <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSEngine::QJSEngine(QObject* parent)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#QJSEngine-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> object with the given <i>parent</i>.</p>
    /// <p>The <a href="http://doc.qt.io/qt-5/qjsengine.html#globalObject">globalObject</a>() is initialized to have properties as described in <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm#">ECMA-262</a>, Section 15.1.</p></div>
    #[inline(always)]
    pub unsafe fn new_1a(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QJSEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_QJSEngine1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Creates a JavaScript object of class Array with the given <i>length</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::newArray(unsigned int length = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#newArray">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a JavaScript object of class Array with the given <i>length</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">newObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn new_array_1a(
        &self,
        length: ::std::os::raw::c_uint,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_newArray(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                length,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a JavaScript object of class Array with the given <i>length</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::newArray()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#newArray">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a JavaScript object of class Array with the given <i>length</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">newObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn new_array_0a(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_newArray1(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a JavaScript object of class Error.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::newErrorObject(QJSValue::ErrorType errorType, const QString& message = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#newErrorObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a JavaScript object of class Error.</p>
    /// <p>The prototype of the created object will be <i>errorType</i>.</p>
    /// <p>This function was introduced in  Qt 5.12.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">newObject</a>(), <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError">throwError</a>(), and <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn new_error_object_2a(
        &self,
        error_type: crate::q_j_s_value::ErrorType,
        message: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_newErrorObject(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                error_type,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(message)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a JavaScript object of class Error.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::newErrorObject(QJSValue::ErrorType errorType)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#newErrorObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a JavaScript object of class Error.</p>
    /// <p>The prototype of the created object will be <i>errorType</i>.</p>
    /// <p>This function was introduced in  Qt 5.12.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">newObject</a>(), <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError">throwError</a>(), and <a href="http://doc.qt.io/qt-5/qjsvalue.html#isError">QJSValue::isError</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn new_error_object_1a(
        &self,
        error_type: crate::q_j_s_value::ErrorType,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_newErrorObject1(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                error_type,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a JavaScript object of class Object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::newObject()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#newObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a JavaScript object of class Object.</p>
    /// <p>The prototype of the created object will be the Object prototype object.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newArray">newArray</a>() and <a href="http://doc.qt.io/qt-5/qjsvalue.html#setProperty">QJSValue::setProperty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn new_object(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_newObject(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a JavaScript object that wraps the given <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> The <i>metaObject</i> must outlive the script engine. It is recommended to only use this method with static metaobjects.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::newQMetaObject(const QMetaObject* metaObject)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#newQMetaObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a JavaScript object that wraps the given <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> The <i>metaObject</i> must outlive the script engine. It is recommended to only use this method with static metaobjects.</p>
    /// <p>When called as a constructor, a new instance of the class will be created. Only constructors exposed by <a href="http://doc.qt.io/qt-5/qobject.html#Q_INVOKABLE">Q_INVOKABLE</a> will be visible from the script engine.</p>
    /// <p>This function was introduced in  Qt 5.8.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#newQObject">newQObject</a>() and <a href="http://doc.qt.io/qt-5/qjsengine.html#qobject-integration">QObject Integration</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new_q_meta_object(
        &self,
        meta_object: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QMetaObject>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_newQMetaObject(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QMetaObject>>::cast_into(
                    meta_object,
                )
                .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a JavaScript object that wraps the given <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>object</i>, using JavaScriptOwnership.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSEngine::newQObject(QObject* object)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#newQObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a JavaScript object that wraps the given <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>object</i>, using JavaScriptOwnership.</p>
    /// <p>Signals and slots, properties and children of <i>object</i> are available as properties of the created <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    /// <p>If <i>object</i> is a null pointer, this function returns a null value.</p>
    /// <p>If a default prototype has been registered for the <i>object</i>'s class (or its superclass, recursively), the prototype of the new script object will be set to be that default prototype.</p>
    /// <p>If the given <i>object</i> is deleted outside of the engine's control, any attempt to access the deleted <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>'s members through the JavaScript wrapper object (either by script code or C++) will result in a <a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">script exception</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalue.html#toQObject">QJSValue::toQObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn new_q_object(
        &self,
        object: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSEngine_newQObject(
                self as *const crate::QJSEngine as *mut crate::QJSEngine,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(object)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QJSEngine::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_qt_metacall(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QJSEngine::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_qt_metacast(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            arg1,
        )
    }

    /// <p>Interrupts or re-enables JavaScript execution.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::setInterrupted(bool interrupted)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#setInterrupted">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Interrupts or re-enables JavaScript execution.</p>
    /// <p>If <i>interrupted</i> is <code>true</code>, any JavaScript executed by this engine immediately aborts and returns an error object until this function is called again with a value of <code>false</code> for <i>interrupted</i>.</p>
    /// <p>This function is thread safe. You may call it from a different thread in order to interrupt, for example, an infinite loop in JavaScript.</p>
    /// <p>This function was introduced in  Qt 5.14.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#isInterrupted">isInterrupted</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(cpp_lib_version = "5.14.0"))
    )]
    #[cfg(any(cpp_lib_version = "5.14.0", feature = "ritual_rustdoc"))]
    pub unsafe fn set_interrupted(&self, interrupted: bool) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_setInterrupted(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            interrupted,
        )
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSEngine_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Throws a run-time error (exception) with the given <i>message</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::throwError(const QString& message)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Throws a run-time error (exception) with the given <i>message</i>.</p>
    /// <p>This method is the C++ counterpart of a <code>throw()</code> expression in JavaScript. It enables C++ code to report run-time errors to <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a>. Therefore it should only be called from C++ code that was invoked by a JavaScript function through <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a>.</p>
    /// <p>When returning from C++, the engine will interrupt the normal flow of execution and call the the next pre-registered exception handler with an error object that contains the given <i>message</i>. The error object will point to the location of the top-most context on the JavaScript caller stack; specifically, it will have properties <code>lineNumber</code>, <code>fileName</code> and <code>stack</code>. These properties are described in <a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">Script Exceptions</a>.</p>
    /// <p>In the following example a C++ method in <i>FileAccess.cpp</i> throws an error in <i>qmlFile.qml</i> at the position where <code>readFileAsText()</code> is called:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="comment">// qmlFile.qml</span>
    ///   function someFunction() {
    /// &#32;   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    /// &#32;   var text <span class="operator">=</span> FileAccess<span class="operator">.</span>readFileAsText(<span class="string">"/path/to/file.txt"</span>);
    ///   }
    ///
    /// </pre>
    /// <pre class="cpp">
    ///
    ///   <span class="comment">// FileAccess.cpp</span>
    ///   <span class="comment">// Assuming that FileAccess is a QObject-derived class that has been</span>
    ///   <span class="comment">// registered as a singleton type and provides an invokable method</span>
    ///   <span class="comment">// readFileAsText()</span>
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a></span> FileAccess<span class="operator">::</span>readFileAsText(<span class="keyword">const</span> <span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span> <span class="operator">&amp;</span> filePath) {
    /// &#32;   <span class="type"><a href="http://doc.qt.io/qt-5/qfile.html">QFile</a></span> file(filePath);
    ///
    /// &#32;   <span class="keyword">if</span> (<span class="operator">!</span>file<span class="operator">.</span>open(<span class="type"><a href="http://doc.qt.io/qt-5/qiodevice.html">QIODevice</a></span><span class="operator">::</span>ReadOnly)) {
    /// &#32;     jsEngine<span class="operator">-</span><span class="operator">&gt;</span>throwError(file<span class="operator">.</span>errorString());
    /// &#32;     <span class="keyword">return</span> <span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span>();
    /// &#32;   }
    ///
    /// &#32;   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    /// &#32;   <span class="keyword">return</span> content;
    ///   }
    ///
    /// </pre>
    /// <p>It is also possible to catch the thrown error in JavaScript:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="comment">// qmlFile.qml</span>
    ///   function someFunction() {
    /// &#32;   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    /// &#32;   var text;
    /// &#32;   <span class="keyword">try</span> {
    /// &#32;     text <span class="operator">=</span> FileAccess<span class="operator">.</span>readFileAsText(<span class="string">"/path/to/file.txt"</span>);
    /// &#32;   } <span class="keyword">catch</span> (error) {
    /// &#32;     console<span class="operator">.</span>warn(<span class="string">"In "</span> <span class="operator">+</span> error<span class="operator">.</span>fileName <span class="operator">+</span> <span class="string">":"</span> <span class="operator">+</span> <span class="string">"error.lineNumber"</span> <span class="operator">+</span>
    /// &#32;   &#32;   &#32;   &#32;      <span class="string">": "</span> <span class="operator">+</span> error<span class="operator">.</span>message);
    /// &#32;   }
    ///   }
    ///
    /// </pre>
    /// <p>If you need a more specific run-time error to describe an exception, you can use the <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError-1">throwError(QJSValue::ErrorType errorType, const QString &amp;message)</a> overload.</p>
    /// <p>This function was introduced in  Qt 5.12.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">Script Exceptions</a>.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn throw_error_q_string(
        &self,
        message: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_throwError(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(message)
                .as_raw_ptr(),
        )
    }

    /// <p>This function overloads <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError">throwError</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::throwError(QJSValue::ErrorType errorType, const QString& message = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function overloads <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError">throwError</a>().</p>
    /// <p>Throws a run-time error (exception) with the given <i>errorType</i> and <i>message</i>.</p>
    /// <pre class="cpp">
    ///
    ///   <span class="comment">// Assuming that DataEntry is a QObject-derived class that has been</span>
    ///   <span class="comment">// registered as a singleton type and provides an invokable method</span>
    ///   <span class="comment">// setAge().</span>
    ///
    ///   <span class="type">void</span> DataEntry<span class="operator">::</span>setAge(<span class="type">int</span> age) {
    /// &#32;   <span class="keyword">if</span> (age <span class="operator">&lt;</span> <span class="number">0</span> <span class="operator">|</span><span class="operator">|</span> age <span class="operator">&gt;</span> <span class="number">200</span>) {
    /// &#32;     jsEngine<span class="operator">-</span><span class="operator">&gt;</span>throwError(<span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a></span><span class="operator">::</span>RangeError<span class="operator">,</span>
    /// &#32;   &#32;   &#32;   &#32;   &#32;   &#32;      <span class="string">"Age must be between 0 and 200"</span>);
    /// &#32;   }
    /// &#32;   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   }
    ///
    /// </pre>
    /// <p>This function was introduced in  Qt 5.12.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">Script Exceptions</a> and <a href="http://doc.qt.io/qt-5/qjsengine.html#newErrorObject">newErrorObject</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn throw_error_error_type_q_string(
        &self,
        error_type: crate::q_j_s_value::ErrorType,
        message: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_throwError1(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            error_type,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(message)
                .as_raw_ptr(),
        )
    }

    /// <p>This function overloads <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError">throwError</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QJSEngine::throwError(QJSValue::ErrorType errorType)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function overloads <a href="http://doc.qt.io/qt-5/qjsengine.html#throwError">throwError</a>().</p>
    /// <p>Throws a run-time error (exception) with the given <i>errorType</i> and <i>message</i>.</p>
    /// <pre class="cpp">
    ///
    ///   <span class="comment">// Assuming that DataEntry is a QObject-derived class that has been</span>
    ///   <span class="comment">// registered as a singleton type and provides an invokable method</span>
    ///   <span class="comment">// setAge().</span>
    ///
    ///   <span class="type">void</span> DataEntry<span class="operator">::</span>setAge(<span class="type">int</span> age) {
    /// &#32;   <span class="keyword">if</span> (age <span class="operator">&lt;</span> <span class="number">0</span> <span class="operator">|</span><span class="operator">|</span> age <span class="operator">&gt;</span> <span class="number">200</span>) {
    /// &#32;     jsEngine<span class="operator">-</span><span class="operator">&gt;</span>throwError(<span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a></span><span class="operator">::</span>RangeError<span class="operator">,</span>
    /// &#32;   &#32;   &#32;   &#32;   &#32;   &#32;      <span class="string">"Age must be between 0 and 200"</span>);
    /// &#32;   }
    /// &#32;   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   }
    ///
    /// </pre>
    /// <p>This function was introduced in  Qt 5.12.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsengine.html#script-exceptions">Script Exceptions</a> and <a href="http://doc.qt.io/qt-5/qjsengine.html#newErrorObject">newErrorObject</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn throw_error_error_type(&self, error_type: crate::q_j_s_value::ErrorType) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_throwError2(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
            error_type,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QJSEngine::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSEngine_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QJSEngine::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QJSEngine_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p>The <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a> constructor takes a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as argument. After construction, the iterator is located at the very beginning of the sequence of properties. Here's how to iterate over all the properties of a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>:</p>
///
/// C++ class: <span style='color: green;'>```QJSValueIterator```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a> constructor takes a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a> as argument. After construction, the iterator is located at the very beginning of the sequence of properties. Here's how to iterate over all the properties of a <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a></span> object;
///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#QJSValueIterator">QJSValueIterator</a></span> it(object);
///   <span class="keyword">while</span> (it<span class="operator">.</span>hasNext()) {
/// &#32;     it<span class="operator">.</span>next();
/// &#32;     <a href="http://doc.qt.io/qt-5/#qDebug">qDebug</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> it<span class="operator">.</span>name() <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">": "</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> it<span class="operator">.</span>value()<span class="operator">.</span>toString();
///   }
///
/// </pre>
/// <p>The <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#next">next</a>() advances the iterator. The <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#name">name</a>() and <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#value">value</a>() functions return the name and value of the last item that was jumped over.</p>
/// <p>Note that <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html">QJSValueIterator</a> only iterates over the <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>'s own properties; i.e. it does not follow the prototype chain. You can use a loop like this to follow the prototype chain:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a></span> obj <span class="operator">=</span> <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>; <span class="comment">// the object to iterate over</span>
///   <span class="keyword">while</span> (obj<span class="operator">.</span>isObject()) {
/// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#QJSValueIterator">QJSValueIterator</a></span> it(obj);
/// &#32;     <span class="keyword">while</span> (it<span class="operator">.</span>hasNext()) {
/// &#32;   &#32;     it<span class="operator">.</span>next();
/// &#32;   &#32;     <a href="http://doc.qt.io/qt-5/#qDebug">qDebug</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> it<span class="operator">.</span>name();
/// &#32;     }
/// &#32;     obj <span class="operator">=</span> obj<span class="operator">.</span>prototype();
///   }
///
/// </pre></div>
#[repr(C)]
pub struct QJSValueIterator {
    _unused: u8,
}
impl QJSValueIterator {
    /// <p>Makes the iterator operate on <i>object</i>. The iterator is set to be at the front of the sequence of properties (before the first property).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValueIterator& QJSValueIterator::operator=(QJSValue& value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Makes the iterator operate on <i>object</i>. The iterator is set to be at the front of the sequence of properties (before the first property).</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::Ref<crate::QJSValueIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValueIterator_operator_(
                self as *const crate::QJSValueIterator as *mut crate::QJSValueIterator,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(value)
                    .as_raw_ptr() as *mut crate::QJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns true if there is at least one item ahead of the iterator (i.e. the iterator is <i>not</i> at the back of the property sequence); otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValueIterator::hasNext() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#hasNext">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if there is at least one item ahead of the iterator (i.e. the iterator is <i>not</i> at the back of the property sequence); otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#next">next</a>().</p></div>
    #[inline(always)]
    pub unsafe fn has_next(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValueIterator_hasNext(
            self as *const crate::QJSValueIterator,
        )
    }

    /// <p>Returns the name of the last property that was jumped over using <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#next">next</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QJSValueIterator::name() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#name">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the name of the last property that was jumped over using <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#next">next</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#value">value</a>().</p></div>
    #[inline(always)]
    pub unsafe fn name(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValueIterator_name(
                self as *const crate::QJSValueIterator,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs an iterator for traversing <i>object</i>. The iterator is set to be at the front of the sequence of properties (before the first property).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QJSValueIterator::QJSValueIterator(const QJSValue& value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#QJSValueIterator">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an iterator for traversing <i>object</i>. The iterator is set to be at the front of the sequence of properties (before the first property).</p></div>
    #[inline(always)]
    pub unsafe fn new(
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QJSValueIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValueIterator_QJSValueIterator(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(value)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Advances the iterator by one position. Returns true if there was at least one item ahead of the iterator (i.e. the iterator was <i>not</i> already at the back of the property sequence); otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QJSValueIterator::next()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#next">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Advances the iterator by one position. Returns true if there was at least one item ahead of the iterator (i.e. the iterator was <i>not</i> already at the back of the property sequence); otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#hasNext">hasNext</a>() and <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#name">name</a>().</p></div>
    #[inline(always)]
    pub unsafe fn next(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QJSValueIterator_next(
            self as *const crate::QJSValueIterator as *mut crate::QJSValueIterator,
        )
    }

    /// <p>Returns the value of the last property that was jumped over using <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#next">next</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QJSValueIterator::value() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#value">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value of the last property that was jumped over using <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#next">next</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#name">name</a>().</p></div>
    #[inline(always)]
    pub unsafe fn value(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QJSValueIterator_value(
                self as *const crate::QJSValueIterator,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p><a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a> provides a mechanism for classes instantiated by a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to receive notification at key points in their creation.</p>
///
/// C++ class: <span style='color: green;'>```QQmlParserStatus```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a> provides a mechanism for classes instantiated by a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to receive notification at key points in their creation.</p>
/// <p>This class is often used for optimization purposes, as it allows you to defer an expensive operation until after all the properties have been set on an object. For example, QML's <a href="http://doc.qt.io/qt-5/qml-qtquick-text.html">Text</a> element uses the parser status to defer text layout until all of its properties have been set (we don't want to layout when the <code>text</code> is assigned, and then relayout when the <code>font</code> is assigned, and relayout again when the <code>width</code> is assigned, and so on).</p>
/// <p>Be aware that <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a> methods are only called when a class is instantiated by a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>. If you create the same class directly from C++, these methods will not be called automatically. To avoid this problem, it is recommended that you start deferring operations from <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html#classBegin">classBegin</a> instead of from the initial creation of your class. This will still prevent multiple revaluations during initial binding assignment in QML, but will not defer operations invoked from C++.</p>
/// <p>To use <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a>, you must inherit both a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>-derived class and <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a>, and use the <a href="http://doc.qt.io/qt-5/qobject.html#Q_INTERFACES">Q_INTERFACES</a>() macro.</p>
/// <pre class="cpp">
///
///   <span class="keyword">class</span> MyObject : <span class="keyword">public</span> <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a></span><span class="operator">,</span> <span class="keyword">public</span> <span class="type">QQmlParserStatus</span>
///   {
/// &#32;     Q_OBJECT
/// &#32;     Q_INTERFACES(<span class="type">QQmlParserStatus</span>)
///
///   <span class="keyword">public</span>:
/// &#32;     MyObject(<span class="type"><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a></span> <span class="operator">*</span>parent <span class="operator">=</span> <span class="number">0</span>);
/// &#32;     <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
/// &#32;     <span class="type">void</span> classBegin();
/// &#32;     <span class="type">void</span> componentComplete();
///   }
///
/// </pre></div>
#[repr(C)]
pub struct QQmlParserStatus {
    _unused: u8,
}
impl QQmlParserStatus {
    /// <p>Invoked after class creation, but before any properties have been set.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```pure virtual void QQmlParserStatus::classBegin()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html#classBegin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Invoked after class creation, but before any properties have been set.</p></div>
    #[inline(always)]
    pub unsafe fn class_begin(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlParserStatus_classBegin(
            self as *const crate::QQmlParserStatus as *mut crate::QQmlParserStatus,
        )
    }

    /// <p>Invoked after the root component that caused this instantiation has completed construction. At this point all static values and binding values have been assigned to the class.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```pure virtual void QQmlParserStatus::componentComplete()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html#componentComplete">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Invoked after the root component that caused this instantiation has completed construction. At this point all static values and binding values have been assigned to the class.</p></div>
    #[inline(always)]
    pub unsafe fn component_complete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlParserStatus_componentComplete(
            self as *const crate::QQmlParserStatus as *mut crate::QQmlParserStatus,
        )
    }

    /// <p><a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a> provides a mechanism for classes instantiated by a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to receive notification at key points in their creation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlParserStatus& QQmlParserStatus::operator=(const QQmlParserStatus& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a> provides a mechanism for classes instantiated by a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to receive notification at key points in their creation.</p>
    /// <p>This class is often used for optimization purposes, as it allows you to defer an expensive operation until after all the properties have been set on an object. For example, QML's <a href="http://doc.qt.io/qt-5/qml-qtquick-text.html">Text</a> element uses the parser status to defer text layout until all of its properties have been set (we don't want to layout when the <code>text</code> is assigned, and then relayout when the <code>font</code> is assigned, and relayout again when the <code>width</code> is assigned, and so on).</p>
    /// <p>Be aware that <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a> methods are only called when a class is instantiated by a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>. If you create the same class directly from C++, these methods will not be called automatically. To avoid this problem, it is recommended that you start deferring operations from <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html#classBegin">classBegin</a> instead of from the initial creation of your class. This will still prevent multiple revaluations during initial binding assignment in QML, but will not defer operations invoked from C++.</p>
    /// <p>To use <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a>, you must inherit both a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>-derived class and <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html">QQmlParserStatus</a>, and use the <a href="http://doc.qt.io/qt-5/qobject.html#Q_INTERFACES">Q_INTERFACES</a>() macro.</p>
    /// <pre class="cpp">
    ///
    ///   <span class="keyword">class</span> MyObject : <span class="keyword">public</span> <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a></span><span class="operator">,</span> <span class="keyword">public</span> <span class="type">QQmlParserStatus</span>
    ///   {
    /// &#32;     Q_OBJECT
    /// &#32;     Q_INTERFACES(<span class="type">QQmlParserStatus</span>)
    ///
    ///   <span class="keyword">public</span>:
    /// &#32;     MyObject(<span class="type"><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a></span> <span class="operator">*</span>parent <span class="operator">=</span> <span class="number">0</span>);
    /// &#32;     <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    /// &#32;     <span class="type">void</span> classBegin();
    /// &#32;     <span class="type">void</span> componentComplete();
    ///   }
    ///
    /// </pre></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlParserStatus>>,
    ) -> ::cpp_core::Ref<crate::QQmlParserStatus> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlParserStatus_operator_(
                self as *const crate::QQmlParserStatus as *mut crate::QQmlParserStatus,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlParserStatus>>::cast_into(other)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }
}

/// <p>See <a href="http://doc.qt.io/qt-5/qtqml-cppintegration-definetypes.html#property-value-sources">Property Value Sources</a> for information on writing custom property value sources.</p>
///
/// C++ class: <span style='color: green;'>```QQmlPropertyValueSource```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlpropertyvaluesource.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>See <a href="http://doc.qt.io/qt-5/qtqml-cppintegration-definetypes.html#property-value-sources">Property Value Sources</a> for information on writing custom property value sources.</p></div>
#[repr(C)]
pub struct QQmlPropertyValueSource {
    _unused: u8,
}
impl QQmlPropertyValueSource {
    /// <p>See <a href="http://doc.qt.io/qt-5/qtqml-cppintegration-definetypes.html#property-value-sources">Property Value Sources</a> for information on writing custom property value sources.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlPropertyValueSource& QQmlPropertyValueSource::operator=(const QQmlPropertyValueSource& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertyvaluesource.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>See <a href="http://doc.qt.io/qt-5/qtqml-cppintegration-definetypes.html#property-value-sources">Property Value Sources</a> for information on writing custom property value sources.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlPropertyValueSource>>,
    ) -> ::cpp_core::Ref<crate::QQmlPropertyValueSource> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyValueSource_operator_(
                self as *const crate::QQmlPropertyValueSource
                    as *mut crate::QQmlPropertyValueSource,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlPropertyValueSource>>::cast_into(
                    other,
                )
                .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Set the target <i>property</i> for the value source. This method will be called by the QML engine when assigning a value source.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```pure virtual void QQmlPropertyValueSource::setTarget(const QQmlProperty& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertyvaluesource.html#setTarget">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set the target <i>property</i> for the value source. This method will be called by the QML engine when assigning a value source.</p></div>
    #[inline(always)]
    pub unsafe fn set_target(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlProperty>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyValueSource_setTarget(
            self as *const crate::QQmlPropertyValueSource as *mut crate::QQmlPropertyValueSource,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlProperty>>::cast_into(arg1)
                .as_raw_ptr(),
        )
    }
}

/// <p><a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> allows C++ programs to read from, and assign values to a QML list property in a simple and type-safe way. A <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> can be created by passing an object and property name or through a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> instance. These two are equivalent:</p>
///
/// C++ class: <span style='color: green;'>```QQmlListReference```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmllistreference.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> allows C++ programs to read from, and assign values to a QML list property in a simple and type-safe way. A <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> can be created by passing an object and property name or through a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> instance. These two are equivalent:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmllistreference.html#QQmlListReference">QQmlListReference</a></span> ref1(object<span class="operator">,</span> <span class="string">"children"</span>);
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a></span> ref2(object<span class="operator">,</span> <span class="string">"children"</span>);
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmllistreference.html#QQmlListReference">QQmlListReference</a></span> ref2 <span class="operator">=</span> qvariant_cast<span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qqmllistreference.html#QQmlListReference">QQmlListReference</a></span><span class="operator">&gt;</span>(ref2<span class="operator">.</span>read());
///
/// </pre>
/// <p>Not all QML list properties support all operations. A set of methods, <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canAppend">canAppend</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canAt">canAt</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canClear">canClear</a>() and <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canCount">canCount</a>() allow programs to query whether an operation is supported on a given property.</p>
/// <p>QML list properties are type-safe. Only <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>'s that derive from the correct base class can be assigned to the list. The <a href="http://doc.qt.io/qt-5/qqmllistreference.html#listElementType">listElementType</a>() method can be used to query the <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> of the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> type supported. Attempting to add objects of the incorrect type to a list property will fail.</p>
/// <p>Like with normal lists, when accessing a list element by index, it is the callers responsibility to ensure that it does not request an out of range element using the <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>() method before calling <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>().</p></div>
#[repr(C)]
pub struct QQmlListReference {
    _unused: u8,
}
impl QQmlListReference {
    /// <p>Appends <i>object</i> to the list. Returns true if the operation succeeded, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::append(QObject* arg1) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#append">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends <i>object</i> to the list. Returns true if the operation succeeded, otherwise false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#canAppend">canAppend</a>().</p></div>
    #[inline(always)]
    pub unsafe fn append(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_append(
            self as *const crate::QQmlListReference,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
        )
    }

    /// <p>Returns the list element at <i>index</i>, or 0 if the operation failed.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlListReference::at(int arg1) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the list element at <i>index</i>, or 0 if the operation failed.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#canAt">canAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn at(&self, arg1: ::std::os::raw::c_int) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_at(
                self as *const crate::QQmlListReference,
                arg1,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns true if the list property can be appended to, otherwise false. Returns false if the reference is invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::canAppend() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canAppend">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the list property can be appended to, otherwise false. Returns false if the reference is invalid.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#append">append</a>().</p></div>
    #[inline(always)]
    pub unsafe fn can_append(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_canAppend(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Returns true if the list property can queried by index, otherwise false. Returns false if the reference is invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::canAt() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the list property can queried by index, otherwise false. Returns false if the reference is invalid.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>().</p></div>
    #[inline(always)]
    pub unsafe fn can_at(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_canAt(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Returns true if the list property can be cleared, otherwise false. Returns false if the reference is invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::canClear() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canClear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the list property can be cleared, otherwise false. Returns false if the reference is invalid.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#clear">clear</a>().</p></div>
    #[inline(always)]
    pub unsafe fn can_clear(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_canClear(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Returns true if the list property can be queried for its element count, otherwise false. Returns false if the reference is invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::canCount() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#canCount">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the list property can be queried for its element count, otherwise false. Returns false if the reference is invalid.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>().</p></div>
    #[inline(always)]
    pub unsafe fn can_count(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_canCount(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Clears the list. Returns true if the operation succeeded, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::clear() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#clear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Clears the list. Returns true if the operation succeeded, otherwise false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#canClear">canClear</a>().</p></div>
    #[inline(always)]
    pub unsafe fn clear(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_clear(
            self as *const crate::QQmlListReference,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlListReference& QQmlListReference::operator=(const QQmlListReference& arg1)```</span>.
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlListReference>>,
    ) -> ::cpp_core::Ref<crate::QQmlListReference> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_operator_(
                self as *const crate::QQmlListReference as *mut crate::QQmlListReference,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlListReference>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns the number of objects in the list, or 0 if the operation failed.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlListReference::count() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of objects in the list, or 0 if the operation failed.</p></div>
    #[inline(always)]
    pub unsafe fn count(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_count(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Return true if <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qqmllistreference.html#clear">clear</a>() are implemented, so you can manipulate the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::isManipulable() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#isManipulable">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return true if <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qqmllistreference.html#clear">clear</a>() are implemented, so you can manipulate the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#isReadable">isReadable</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#append">append</a>(), and <a href="http://doc.qt.io/qt-5/qqmllistreference.html#clear">clear</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_manipulable(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_isManipulable(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Return true if <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>() are implemented, so you can access the elements.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::isReadable() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#isReadable">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return true if <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>() are implemented, so you can access the elements.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmllistreference.html#isManipulable">isManipulable</a>(), <a href="http://doc.qt.io/qt-5/qqmllistreference.html#at">at</a>(), and <a href="http://doc.qt.io/qt-5/qqmllistreference.html#count">count</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_readable(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_isReadable(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Returns true if the instance refers to a valid list property, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlListReference::isValid() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#isValid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the instance refers to a valid list property, otherwise false.</p></div>
    #[inline(always)]
    pub unsafe fn is_valid(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_isValid(
            self as *const crate::QQmlListReference,
        )
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> for the elements stored in the list property, or <code>nullptr</code> if the reference is invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QMetaObject* QQmlListReference::listElementType() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#listElementType">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> for the elements stored in the list property, or <code>nullptr</code> if the reference is invalid.</p>
    /// <p>The <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> can be used ahead of time to determine whether a given instance can be added to a list.</p></div>
    #[inline(always)]
    pub unsafe fn list_element_type(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_listElementType(
                self as *const crate::QQmlListReference,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Constructs an invalid instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlListReference::QQmlListReference()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#QQmlListReference">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an invalid instance.</p></div>
    #[inline(always)]
    pub unsafe fn new_0a() -> ::cpp_core::CppBox<crate::QQmlListReference> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_QQmlListReference() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> for <i>object</i>'s <i>property</i>. If <i>property</i> is not a list property, an invalid <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> is created. If <i>object</i> is destroyed after the reference is constructed, it will automatically become invalid. That is, it is safe to hold <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> instances even after <i>object</i> is deleted.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlListReference::QQmlListReference(QObject* arg1, const char* property, QQmlEngine* arg3 = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#QQmlListReference-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> for <i>object</i>'s <i>property</i>. If <i>property</i> is not a list property, an invalid <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> is created. If <i>object</i> is destroyed after the reference is constructed, it will automatically become invalid. That is, it is safe to hold <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> instances even after <i>object</i> is deleted.</p>
    /// <p>Passing <i>engine</i> is required to access some QML created list properties. If in doubt, and an engine is available, pass it.</p></div>
    #[inline(always)]
    pub unsafe fn new_3a(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        property: *const ::std::os::raw::c_char,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::cpp_core::CppBox<crate::QQmlListReference> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_QQmlListReference1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                property,
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg3)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> for <i>object</i>'s <i>property</i>. If <i>property</i> is not a list property, an invalid <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> is created. If <i>object</i> is destroyed after the reference is constructed, it will automatically become invalid. That is, it is safe to hold <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> instances even after <i>object</i> is deleted.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlListReference::QQmlListReference(QObject* arg1, const char* property)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#QQmlListReference-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> for <i>object</i>'s <i>property</i>. If <i>property</i> is not a list property, an invalid <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> is created. If <i>object</i> is destroyed after the reference is constructed, it will automatically become invalid. That is, it is safe to hold <a href="http://doc.qt.io/qt-5/qqmllistreference.html">QQmlListReference</a> instances even after <i>object</i> is deleted.</p>
    /// <p>Passing <i>engine</i> is required to access some QML created list properties. If in doubt, and an engine is available, pass it.</p></div>
    #[inline(always)]
    pub unsafe fn new_2a(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        property: *const ::std::os::raw::c_char,
    ) -> ::cpp_core::CppBox<crate::QQmlListReference> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_QQmlListReference3(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                property,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlListReference::QQmlListReference(const QQmlListReference& arg1)```</span>.
    #[inline(always)]
    pub unsafe fn new_copy(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlListReference>>,
    ) -> ::cpp_core::CppBox<crate::QQmlListReference> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_QQmlListReference2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlListReference>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the list property's object. Returns <code>nullptr</code> if the reference is invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlListReference::object() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmllistreference.html#object">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the list property's object. Returns <code>nullptr</code> if the reference is invalid.</p></div>
    #[inline(always)]
    pub unsafe fn object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_object(
                self as *const crate::QQmlListReference,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }
}

pub mod qt_qml;
pub mod q_qml_abstract_url_interceptor {
    //! C++ type: <span style='color: green;'>```QQmlAbstractUrlInterceptor```</span>

    /// <p>Specifies where URL interception is taking place.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlAbstractUrlInterceptor::DataType```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html#DataType-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Specifies where URL interception is taking place.</p>
    /// <p>Because QML loads qmldir files for locating types, there are two URLs involved in loading a QML type. The URL of the (possibly implicit) qmldir used for locating the type and the URL of the file which defines the type. Intercepting both leads to either complex URL replacement or double URL replacements for the same file.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct DataType(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for DataType {
        fn from(value: ::std::os::raw::c_int) -> Self {
            DataType(value)
        }
    }

    impl From<DataType> for ::std::os::raw::c_int {
        fn from(value: DataType) -> Self {
            value.0
        }
    }

    impl DataType {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl DataType {
        /// The URL being intercepted is for a Qml file. Intercepting this, but not the Qmldir file, leaves the base dir of a QML file untouched and acts like replacing the file with another file. (C++ enum variant: <span style='color: green;'>```QmlFile = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const QmlFile: crate::q_qml_abstract_url_interceptor::DataType =
            crate::q_qml_abstract_url_interceptor::DataType(0);
        /// The URL being intercepted is an import for a Javascript file. (C++ enum variant: <span style='color: green;'>```JavaScriptFile = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const JavaScriptFile: crate::q_qml_abstract_url_interceptor::DataType =
            crate::q_qml_abstract_url_interceptor::DataType(1);
        /// The URL being intercepted is for a Qmldir file. Intercepting this, but not the QmlFile, allows for swapping out entire sub trees. (C++ enum variant: <span style='color: green;'>```QmldirFile = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const QmldirFile: crate::q_qml_abstract_url_interceptor::DataType =
            crate::q_qml_abstract_url_interceptor::DataType(2);
        /// The URL being intercepted is a url property in a QML file, and not being used to load a file through the engine. (C++ enum variant: <span style='color: green;'>```UrlString = 4096```</span>)
        #[allow(non_upper_case_globals)]
        pub const UrlString: crate::q_qml_abstract_url_interceptor::DataType =
            crate::q_qml_abstract_url_interceptor::DataType(4096);
    }
}
/// <p><a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> is an interface which can be used to alter URLs before they are used by the QML engine. This is primarily useful for altering file urls into other file urls, such as selecting different graphical assets for the current platform.</p>
///
/// C++ class: <span style='color: green;'>```QQmlAbstractUrlInterceptor```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> is an interface which can be used to alter URLs before they are used by the QML engine. This is primarily useful for altering file urls into other file urls, such as selecting different graphical assets for the current platform.</p>
/// <p>Relative URLs are intercepted after being resolved against the file path of the current QML context. URL interception also occurs after setting the base path for a loaded QML file. This means that the content loaded for that QML file uses the intercepted URL, but inside the file the pre-intercepted URL is used for resolving relative paths. This allows for interception of .qml file loading without needing all paths (or local types) inside intercepted content to insert a different relative path.</p>
/// <p>Compared to setNetworkAccessManagerFactory, <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> affects all URLs and paths, including local files and embedded resource files. <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> is synchronous, and for asynchronous files must return a url with an asynchronous scheme (such as http or a custom scheme handled by your own custom QNetworkAccessManager). You can use a <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> to change file URLs into networked URLs which are handled by your own custom QNetworkAccessManager.</p>
/// <p>To implement support for a custom networked scheme, see setNetworkAccessManagerFactory.</p></div>
#[repr(C)]
pub struct QQmlAbstractUrlInterceptor {
    _unused: u8,
}
impl QQmlAbstractUrlInterceptor {
    /// <p><a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> is an interface which can be used to alter URLs before they are used by the QML engine. This is primarily useful for altering file urls into other file urls, such as selecting different graphical assets for the current platform.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlAbstractUrlInterceptor& QQmlAbstractUrlInterceptor::operator=(const QQmlAbstractUrlInterceptor& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> is an interface which can be used to alter URLs before they are used by the QML engine. This is primarily useful for altering file urls into other file urls, such as selecting different graphical assets for the current platform.</p>
    /// <p>Relative URLs are intercepted after being resolved against the file path of the current QML context. URL interception also occurs after setting the base path for a loaded QML file. This means that the content loaded for that QML file uses the intercepted URL, but inside the file the pre-intercepted URL is used for resolving relative paths. This allows for interception of .qml file loading without needing all paths (or local types) inside intercepted content to insert a different relative path.</p>
    /// <p>Compared to setNetworkAccessManagerFactory, <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> affects all URLs and paths, including local files and embedded resource files. <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> is synchronous, and for asynchronous files must return a url with an asynchronous scheme (such as http or a custom scheme handled by your own custom QNetworkAccessManager). You can use a <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a> to change file URLs into networked URLs which are handled by your own custom QNetworkAccessManager.</p>
    /// <p>To implement support for a custom networked scheme, see setNetworkAccessManagerFactory.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlAbstractUrlInterceptor>>,
    ) -> ::cpp_core::Ref<crate::QQmlAbstractUrlInterceptor> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlAbstractUrlInterceptor_operator_(self as *const crate::QQmlAbstractUrlInterceptor as *mut crate::QQmlAbstractUrlInterceptor, ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlAbstractUrlInterceptor>>::cast_into(other).as_raw_ptr())
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>A pure virtual function where you can intercept the <i>url</i>. The returned value is taken as the new value for the url. The type of url being intercepted is given by the <i>type</i> variable.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```pure virtual QUrl QQmlAbstractUrlInterceptor::intercept(const QUrl& path, QQmlAbstractUrlInterceptor::DataType type)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html#intercept">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>A pure virtual function where you can intercept the <i>url</i>. The returned value is taken as the new value for the url. The type of url being intercepted is given by the <i>type</i> variable.</p>
    /// <p>Your implementation of this function must be thread-safe, as it can be called from multiple threads at the same time.</p></div>
    #[inline(always)]
    pub unsafe fn intercept(
        &self,
        path: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
        type_: crate::q_qml_abstract_url_interceptor::DataType,
    ) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlAbstractUrlInterceptor_intercept(
                self as *const crate::QQmlAbstractUrlInterceptor
                    as *mut crate::QQmlAbstractUrlInterceptor,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(path)
                    .as_raw_ptr(),
                type_,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p><a href="http://doc.qt.io/qt-5/qqmlerror.html">QQmlError</a> includes a textual description of the error, as well as location information (the file, line, and column). The <a href="http://doc.qt.io/qt-5/qqmlerror.html#toString">toString</a>() method creates a single-line, human-readable string containing all of this information, for example:</p>
///
/// C++ class: <span style='color: green;'>```QQmlError```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlerror.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlerror.html">QQmlError</a> includes a textual description of the error, as well as location information (the file, line, and column). The <a href="http://doc.qt.io/qt-5/qqmlerror.html#toString">toString</a>() method creates a single-line, human-readable string containing all of this information, for example:</p>
/// <pre class="cpp">
///
///   file:<span class="comment">///home/user/test.qml:7:8: Invalid property assignment: double expected</span>
///
/// </pre>
/// <p>You can use <a href="http://doc.qt.io/qt-5/#qDebug">qDebug</a>(), <a href="http://doc.qt.io/qt-5/#qInfo">qInfo</a>(), or <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>() to output errors to the console. This method will attempt to open the file indicated by the error and include additional contextual information.</p>
/// <pre class="cpp">
///
///   file:<span class="comment">///home/user/test.qml:7:8: Invalid property assignment: double expected</span>
/// &#32;   &#32;     y: <span class="string">"hello"</span>
/// &#32;   &#32;   &#32;    <span class="operator">^</span>
///
/// </pre></div>
#[repr(C)]
pub struct QQmlError {
    _unused: u8,
}
impl QQmlError {
    /// <p>Returns the error column number.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlError::column() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#column">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the error column number.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#setColumn">setColumn</a>().</p></div>
    #[inline(always)]
    pub unsafe fn column(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_column(self as *const crate::QQmlError)
    }

    /// <p>Assigns <i>other</i> to this error object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError& QQmlError::operator=(const QQmlError& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns <i>other</i> to this error object.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlError_operator_(
                self as *const crate::QQmlError as *mut crate::QQmlError,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns the error description.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlError::description() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#description">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the error description.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#setDescription">setDescription</a>().</p></div>
    #[inline(always)]
    pub unsafe fn description(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlError_description(self as *const crate::QQmlError) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns true if this error is valid, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlError::isValid() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#isValid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this error is valid, otherwise false.</p></div>
    #[inline(always)]
    pub unsafe fn is_valid(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_isValid(self as *const crate::QQmlError)
    }

    /// <p>Returns the error line number.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlError::line() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#line">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the error line number.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#setLine">setLine</a>().</p></div>
    #[inline(always)]
    pub unsafe fn line(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_line(self as *const crate::QQmlError)
    }

    /// <p>Returns the message type.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QtMsgType QQmlError::messageType() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#messageType">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the message type.</p>
    /// <p>This function was introduced in  Qt 5.9.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#setMessageType">setMessageType</a>().</p></div>
    #[inline(always)]
    pub unsafe fn message_type(&self) -> ::qt_core::QtMsgType {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_messageType(self as *const crate::QQmlError)
    }

    /// <p>Creates an empty error object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlError::QQmlError()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#QQmlError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates an empty error object.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlError_QQmlError() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a copy of <i>other</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlError::QQmlError(const QQmlError& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#QQmlError-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a copy of <i>other</i>.</p></div>
    #[inline(always)]
    pub unsafe fn new_copy(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlError_QQmlError1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the nearest object where this error occurred. Exceptions in bound property expressions set this to the object to which the property belongs. It will be 0 for all other exceptions.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlError::object() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#object">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the nearest object where this error occurred. Exceptions in bound property expressions set this to the object to which the property belongs. It will be 0 for all other exceptions.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#setObject">setObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlError_object(self as *const crate::QQmlError) };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Sets the error <i>column</i> number.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlError::setColumn(int arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#setColumn">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the error <i>column</i> number.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#column">column</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_column(&self, arg1: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_setColumn(
            self as *const crate::QQmlError as *mut crate::QQmlError,
            arg1,
        )
    }

    /// <p>Sets the error <i>description</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlError::setDescription(const QString& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#setDescription">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the error <i>description</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#description">description</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_description(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_setDescription(
            self as *const crate::QQmlError as *mut crate::QQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg1)
                .as_raw_ptr(),
        )
    }

    /// <p>Sets the error <i>line</i> number.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlError::setLine(int arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#setLine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the error <i>line</i> number.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#line">line</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_line(&self, arg1: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_setLine(
            self as *const crate::QQmlError as *mut crate::QQmlError,
            arg1,
        )
    }

    /// <p>Sets the <i>messageType</i> for this message. The message type determines which <a href="http://doc.qt.io/qt-5/qdebug.html">QDebug</a> handlers are responsible for receiving the message.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlError::setMessageType(QtMsgType messageType)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#setMessageType">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <i>messageType</i> for this message. The message type determines which <a href="http://doc.qt.io/qt-5/qdebug.html">QDebug</a> handlers are responsible for receiving the message.</p>
    /// <p>This function was introduced in  Qt 5.9.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#messageType">messageType</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_message_type(&self, message_type: ::qt_core::QtMsgType) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_setMessageType(
            self as *const crate::QQmlError as *mut crate::QQmlError,
            message_type,
        )
    }

    /// <p>Sets the nearest <i>object</i> where this error occurred.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlError::setObject(QObject* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#setObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the nearest <i>object</i> where this error occurred.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#object">object</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_object(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_setObject(
            self as *const crate::QQmlError as *mut crate::QQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
        )
    }

    /// <p>Sets the <i>url</i> for the file that caused this error.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlError::setUrl(const QUrl& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#setUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <i>url</i> for the file that caused this error.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#url">url</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_url(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_setUrl(
            self as *const crate::QQmlError as *mut crate::QQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg1).as_raw_ptr(),
        )
    }

    /// <p>Returns the error as a human readable string.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlError::toString() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#toString">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the error as a human readable string.</p></div>
    #[inline(always)]
    pub unsafe fn to_string(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlError_toString(self as *const crate::QQmlError) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the url for the file that caused this error.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QUrl QQmlError::url() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlerror.html#url">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the url for the file that caused this error.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlerror.html#setUrl">setUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn url(&self) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlError_url(self as *const crate::QQmlError) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_qml_image_provider_base {
    //! C++ type: <span style='color: green;'>```QQmlImageProviderBase```</span>

    /// <p>Defines the type of image supported by this image provider.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlImageProviderBase::ImageType```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html#ImageType-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Defines the type of image supported by this image provider.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct ImageType(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for ImageType {
        fn from(value: ::std::os::raw::c_int) -> Self {
            ImageType(value)
        }
    }

    impl From<ImageType> for ::std::os::raw::c_int {
        fn from(value: ImageType) -> Self {
            value.0
        }
    }

    impl ImageType {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl ImageType {
        /// The Image Provider provides <a href="http://doc.qt.io/qt-5/qimage.html">QImage</a> images. The <a href="http://doc.qt.io/qt-5/qquickimageprovider.html#requestImage">QQuickImageProvider::requestImage</a>() method will be called for all image requests. (C++ enum variant: <span style='color: green;'>```Image = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const Image: crate::q_qml_image_provider_base::ImageType =
            crate::q_qml_image_provider_base::ImageType(0);
        /// The Image Provider provides <a href="http://doc.qt.io/qt-5/qpixmap.html">QPixmap</a> images. The <a href="http://doc.qt.io/qt-5/qquickimageprovider.html#requestPixmap">QQuickImageProvider::requestPixmap</a>() method will be called for all image requests. (C++ enum variant: <span style='color: green;'>```Pixmap = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const Pixmap: crate::q_qml_image_provider_base::ImageType =
            crate::q_qml_image_provider_base::ImageType(1);
        /// The Image Provider provides <a href="http://doc.qt.io/qt-5/qsgtextureprovider.html">QSGTextureProvider</a> based images. The <a href="http://doc.qt.io/qt-5/qquickimageprovider.html#requestTexture">QQuickImageProvider::requestTexture</a>() method will be called for all image requests. (C++ enum variant: <span style='color: green;'>```Texture = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const Texture: crate::q_qml_image_provider_base::ImageType =
            crate::q_qml_image_provider_base::ImageType(2);
        /// C++ enum variant: <span style='color: green;'>```Invalid = 3```</span>
        #[allow(non_upper_case_globals)]
        pub const Invalid: crate::q_qml_image_provider_base::ImageType =
            crate::q_qml_image_provider_base::ImageType(3);
        /// The Image provider provides <a href="http://doc.qt.io/qt-5/qquicktexturefactory.html">QQuickTextureFactory</a> based images. Should only be used in <a href="http://doc.qt.io/qt-5/qquickasyncimageprovider.html">QQuickAsyncImageProvider</a> or its subclasses. The <a href="http://doc.qt.io/qt-5/qquickasyncimageprovider.html#requestImageResponse">QQuickAsyncImageProvider::requestImageResponse</a>() method will be called for all image requests. Since Qt 5.6 (C++ enum variant: <span style='color: green;'>```ImageResponse = 4```</span>)
        #[allow(non_upper_case_globals)]
        pub const ImageResponse: crate::q_qml_image_provider_base::ImageType =
            crate::q_qml_image_provider_base::ImageType(4);
    }

    /// <p>Defines specific requirements or features of this image provider.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlImageProviderBase::Flag```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html#Flag-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Defines specific requirements or features of this image provider.</p>
    ///
    /// <p>The Flags type is a typedef for <a href="http://doc.qt.io/qt-5/qflags.html">QFlags</a>&lt;Flag&gt;. It stores an OR combination of Flag values.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Flag(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for Flag {
        fn from(value: ::std::os::raw::c_int) -> Self {
            Flag(value)
        }
    }

    impl From<Flag> for ::std::os::raw::c_int {
        fn from(value: Flag) -> Self {
            value.0
        }
    }

    impl Flag {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl Flag {
        /// Ensures that image requests to the provider are run in a separate thread, which allows the provider to spend as much time as needed on producing the image without blocking the main thread. (C++ enum variant: <span style='color: green;'>```ForceAsynchronousImageLoading = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const ForceAsynchronousImageLoading: crate::q_qml_image_provider_base::Flag =
            crate::q_qml_image_provider_base::Flag(1);
    }

    impl From<crate::q_qml_image_provider_base::Flag>
        for ::qt_core::QFlags<crate::q_qml_image_provider_base::Flag>
    {
        fn from(value: crate::q_qml_image_provider_base::Flag) -> Self {
            Self::from(value.to_int())
        }
    }

    impl<T: Into<::qt_core::QFlags<crate::q_qml_image_provider_base::Flag>>> std::ops::BitOr<T>
        for crate::q_qml_image_provider_base::Flag
    {
        type Output = ::qt_core::QFlags<crate::q_qml_image_provider_base::Flag>;
        fn bitor(self, rhs: T) -> ::qt_core::QFlags<crate::q_qml_image_provider_base::Flag> {
            Into::<::qt_core::QFlags<crate::q_qml_image_provider_base::Flag>>::into(self) | rhs
        }
    }
}
/// <p>Image providers must be registered with the QML engine. The only information the QML engine knows about image providers is the type of image data they provide. To use an image provider to acquire image data, you must cast the <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html">QQmlImageProviderBase</a> pointer to a <a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a> pointer.</p>
///
/// C++ class: <span style='color: green;'>```QQmlImageProviderBase```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Image providers must be registered with the QML engine. The only information the QML engine knows about image providers is the type of image data they provide. To use an image provider to acquire image data, you must cast the <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html">QQmlImageProviderBase</a> pointer to a <a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a> pointer.</p></div>
#[repr(C)]
pub struct QQmlImageProviderBase {
    _unused: u8,
}
impl QQmlImageProviderBase {
    /// <p>Image providers must be registered with the QML engine. The only information the QML engine knows about image providers is the type of image data they provide. To use an image provider to acquire image data, you must cast the <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html">QQmlImageProviderBase</a> pointer to a <a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a> pointer.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlImageProviderBase& QQmlImageProviderBase::operator=(const QQmlImageProviderBase& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Image providers must be registered with the QML engine. The only information the QML engine knows about image providers is the type of image data they provide. To use an image provider to acquire image data, you must cast the <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html">QQmlImageProviderBase</a> pointer to a <a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a> pointer.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlImageProviderBase>>,
    ) -> ::cpp_core::Ref<crate::QQmlImageProviderBase> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlImageProviderBase_operator_(
                self as *const crate::QQmlImageProviderBase as *mut crate::QQmlImageProviderBase,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlImageProviderBase>>::cast_into(
                    other,
                )
                .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Implement this to return the properties of this image provider.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```pure virtual QFlags<QQmlImageProviderBase::Flag> QQmlImageProviderBase::flags() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html#flags">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Implement this to return the properties of this image provider.</p></div>
    #[inline(always)]
    pub unsafe fn flags(&self) -> ::qt_core::QFlags<crate::q_qml_image_provider_base::Flag> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlImageProviderBase_flags(
                self as *const crate::QQmlImageProviderBase,
            )
        };
        ::qt_core::QFlags::from(ffi_result)
    }

    /// <p>Implement this method to return the image type supported by this image provider.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```pure virtual QQmlImageProviderBase::ImageType QQmlImageProviderBase::imageType() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html#imageType">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Implement this method to return the image type supported by this image provider.</p></div>
    #[inline(always)]
    pub unsafe fn image_type(&self) -> crate::q_qml_image_provider_base::ImageType {
        crate::__ffi::ctr_qt_qml_ffi_QQmlImageProviderBase_imageType(
            self as *const crate::QQmlImageProviderBase,
        )
    }
}

pub mod q_qml_engine {
    //! C++ type: <span style='color: green;'>```QQmlEngine```</span>

    /// <p>ObjectOwnership controls whether or not QML automatically destroys the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> when the corresponding JavaScript object is garbage collected by the engine. The two ownership options are:</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlEngine::ObjectOwnership```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#ObjectOwnership-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>ObjectOwnership controls whether or not QML automatically destroys the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> when the corresponding JavaScript object is garbage collected by the engine. The two ownership options are:</p>
    ///
    /// <p>Generally an application doesn't need to set an object's ownership explicitly. QML uses a heuristic to set the default ownership. By default, an object that is created by QML has JavaScriptOwnership. The exception to this are the root objects created by calling <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() or <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#beginCreate">QQmlComponent::beginCreate</a>(), which have CppOwnership by default. The ownership of these root-level objects is considered to have been transferred to the C++ caller.</p>
    /// <p>Objects not-created by QML have CppOwnership by default. The exception to this are objects returned from C++ method calls; their ownership will be set to JavaScriptOwnership. This applies only to explicit invocations of <a href="http://doc.qt.io/qt-5/qobject.html#Q_INVOKABLE">Q_INVOKABLE</a> methods or slots, but not to property getter invocations.</p>
    /// <p>Calling <a href="http://doc.qt.io/qt-5/qqmlengine.html#setObjectOwnership">setObjectOwnership</a>() overrides the default ownership heuristic used by QML.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct ObjectOwnership(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for ObjectOwnership {
        fn from(value: ::std::os::raw::c_int) -> Self {
            ObjectOwnership(value)
        }
    }

    impl From<ObjectOwnership> for ::std::os::raw::c_int {
        fn from(value: ObjectOwnership) -> Self {
            value.0
        }
    }

    impl ObjectOwnership {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl ObjectOwnership {
        /// The object is owned by C++ code and QML will never delete it. The JavaScript destroy() method cannot be used on these objects. This option is similar to <a href="http://doc.qt.io/qt-5/qscriptengine.html#ValueOwnership-enum">QScriptEngine::QtOwnership</a>. (C++ enum variant: <span style='color: green;'>```CppOwnership = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const CppOwnership: crate::q_qml_engine::ObjectOwnership =
            crate::q_qml_engine::ObjectOwnership(0);
        /// The object is owned by JavaScript. When the object is returned to QML as the return value of a method call, QML will track it and delete it if there are no remaining JavaScript references to it and it has no <a href="http://doc.qt.io/qt-5/qobject.html#parent">QObject::parent</a>(). An object tracked by one <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> will be deleted during that <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>'s destructor. Thus, JavaScript references between objects with JavaScriptOwnership from two different engines will not be valid if one of these engines is deleted. This option is similar to <a href="http://doc.qt.io/qt-5/qscriptengine.html#ValueOwnership-enum">QScriptEngine::ScriptOwnership</a>. (C++ enum variant: <span style='color: green;'>```JavaScriptOwnership = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const JavaScriptOwnership: crate::q_qml_engine::ObjectOwnership =
            crate::q_qml_engine::ObjectOwnership(1);
    }
}
/// <p>Each QML component is instantiated in a <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>. <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>'s are essential for passing data to QML components. In QML, contexts are arranged hierarchically and this hierarchy is managed by the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p>
///
/// C++ class: <span style='color: green;'>```QQmlEngine```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Each QML component is instantiated in a <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>. <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>'s are essential for passing data to QML components. In QML, contexts are arranged hierarchically and this hierarchy is managed by the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p>
/// <p>Prior to creating any QML components, an application must have created a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to gain access to a QML context. The following example shows how to create a simple Text item.</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html#QQmlEngine">QQmlEngine</a></span> engine;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a></span> component(<span class="operator">&amp;</span>engine);
///   component<span class="operator">.</span>setData(<span class="string">"import QtQuick 2.0\nText { text: \"Hello world!\" }"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span>());
///   <span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span>item <span class="operator">=</span> qobject_cast<span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span><span class="operator">&gt;</span>(component<span class="operator">.</span>create());
///
///   <span class="comment">//add item to view, etc</span>
///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
///
/// </pre>
/// <p>In this case, the Text item will be created in the engine's <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a>.</p></div>
#[repr(C)]
pub struct QQmlEngine {
    _unused: u8,
}
impl QQmlEngine {
    /// <p>Refreshes all binding expressions that use strings marked for translation.</p>
    ///
    /// Returns a built-in Qt slot `QQmlEngine::retranslate` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#retranslate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Refreshes all binding expressions that use strings marked for translation.</p>
    /// <p>Call this function after you have installed a new translator with <a href="http://doc.qt.io/qt-5/qcoreapplication.html#installTranslator">QCoreApplication::installTranslator</a>, to ensure that your user-interface shows up-to-date translations.</p>
    /// <p><b>Note: </b>Due to a limitation in the implementation, this function refreshes all the engine's bindings, not only those that use strings marked for translation. This may be optimized in a future release.</p><p>This function was introduced in  Qt 5.10.</p></div>
    #[inline(always)]
    pub fn slot_retranslate(&self) -> ::qt_core::Receiver<()> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"1retranslate()\0"),
            )
        }
    }

    /// <p>This signal is emitted when the QML loaded by the engine would like to quit.</p>
    ///
    /// Returns a built-in Qt signal `QQmlEngine::quit` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#quit">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This signal is emitted when the QML loaded by the engine would like to quit.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#exit">exit</a>().</p></div>
    #[inline(always)]
    pub fn quit(&self) -> ::qt_core::Signal<()> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"2quit()\0"),
            )
        }
    }

    /// <p>This signal is emitted when the QML loaded by the engine would like to exit from the event loop with the specified return code <i>retCode</i>.</p>
    ///
    /// Returns a built-in Qt signal `QQmlEngine::exit` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#exit">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This signal is emitted when the QML loaded by the engine would like to exit from the event loop with the specified return code <i>retCode</i>.</p>
    /// <p>This function was introduced in  Qt 5.8.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#quit">quit</a>().</p></div>
    #[inline(always)]
    pub fn exit(&self) -> ::qt_core::Signal<(::std::os::raw::c_int,)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"2exit(int)\0"),
            )
        }
    }

    /// <p>This signal is emitted when <i>warnings</i> messages are generated by QML.</p>
    ///
    /// Returns a built-in Qt signal `QQmlEngine::warnings` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#warnings">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This signal is emitted when <i>warnings</i> messages are generated by QML.</p></div>
    #[inline(always)]
    pub fn warnings(&self) -> ::qt_core::Signal<(*const crate::QListOfQQmlError,)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2warnings(QList< QQmlError > const &)\0",
                ),
            )
        }
    }

    /// <p>Sets the <i>provider</i> to use for images requested via the <i>image</i>: url scheme, with host <i>providerId</i>. The <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> takes ownership of <i>provider</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::addImageProvider(const QString& id, QQmlImageProviderBase* arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#addImageProvider">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <i>provider</i> to use for images requested via the <i>image</i>: url scheme, with host <i>providerId</i>. The <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> takes ownership of <i>provider</i>.</p>
    /// <p>Image providers enable support for pixmap and threaded image requests. See the <a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a> documentation for details on implementing and using image providers.</p>
    /// <p>All required image providers should be added to the engine before any QML sources files are loaded.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#removeImageProvider">removeImageProvider</a>(), <a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a>, and <a href="http://doc.qt.io/qt-5/qqmlimageproviderbase.html">QQmlImageProviderBase</a>.</p></div>
    #[inline(always)]
    pub unsafe fn add_image_provider(
        &self,
        id: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlImageProviderBase>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_addImageProvider(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(id).as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlImageProviderBase>>::cast_into(arg2)
                .as_raw_ptr() as *mut crate::QQmlImageProviderBase,
        )
    }

    /// <p>Adds <i>path</i> as a directory where the engine searches for installed modules in a URL-based directory structure.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::addImportPath(const QString& dir)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#addImportPath">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Adds <i>path</i> as a directory where the engine searches for installed modules in a URL-based directory structure.</p>
    /// <p>The <i>path</i> may be a local filesystem directory, a <a href="http://doc.qt.io/qt-5/resources.html">Qt Resource</a> path (<code>:/imports</code>), a <a href="http://doc.qt.io/qt-5/resources.html">Qt Resource</a> url (<code>qrc:/imports</code>) or a URL.</p>
    /// <p>The <i>path</i> will be converted into canonical form before it is added to the import path list.</p>
    /// <p>The newly added <i>path</i> will be first in the <a href="http://doc.qt.io/qt-5/qqmlengine.html#importPathList">importPathList</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setImportPathList">setImportPathList</a>() and <a href="http://doc.qt.io/qt-5/qtqml-modules-topic.html#">QML Modules</a>.</p></div>
    #[inline(always)]
    pub unsafe fn add_import_path(
        &self,
        dir: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_addImportPath(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(dir)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlEngine::addNamedBundle(const QString& name, const QString& fileName)```</span>.
    #[inline(always)]
    pub unsafe fn add_named_bundle(
        &self,
        name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_addNamedBundle(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(name)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                .as_raw_ptr(),
        )
    }

    /// <p>Adds <i>path</i> as a directory where the engine searches for native plugins for imported modules (referenced in the <code>qmldir</code> file).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::addPluginPath(const QString& dir)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#addPluginPath">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Adds <i>path</i> as a directory where the engine searches for native plugins for imported modules (referenced in the <code>qmldir</code> file).</p>
    /// <p>By default, the list contains only <code>.</code>, i.e. the engine searches in the directory of the <code>qmldir</code> file itself.</p>
    /// <p>The newly added <i>path</i> will be first in the <a href="http://doc.qt.io/qt-5/qqmlengine.html#pluginPathList">pluginPathList</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setPluginPathList">setPluginPathList</a>().</p></div>
    #[inline(always)]
    pub unsafe fn add_plugin_path(
        &self,
        dir: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_addPluginPath(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(dir)
                .as_raw_ptr(),
        )
    }

    /// <p>Return the base URL for this engine. The base URL is only used to resolve components when a relative URL is passed to the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> constructor.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QUrl QQmlEngine::baseUrl() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the base URL for this engine. The base URL is only used to resolve components when a relative URL is passed to the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> constructor.</p>
    /// <p>If a base URL has not been explicitly set, this method returns the application's current working directory.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setBaseUrl">setBaseUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn base_url(&self) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_baseUrl(self as *const crate::QQmlEngine) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Clears the engine's internal component cache.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::clearComponentCache()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#clearComponentCache">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Clears the engine's internal component cache.</p>
    /// <p>This function causes the property metadata of all components previously loaded by the engine to be destroyed. All previously loaded components and the property bindings for all extant objects created from those components will cease to function.</p>
    /// <p>This function returns the engine to a state where it does not contain any loaded component data. This may be useful in order to reload a smaller subset of the previous component set, or to load a new version of a previously loaded component.</p>
    /// <p>Once the component cache has been cleared, components must be loaded before any new objects can be created.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#trimComponentCache">trimComponentCache</a>().</p></div>
    #[inline(always)]
    pub unsafe fn clear_component_cache(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_clearComponentCache(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
        )
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> for the <i>object</i>, or 0 if no context has been set.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QQmlContext* QQmlEngine::contextForObject(const QObject* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#contextForObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> for the <i>object</i>, or 0 if no context has been set.</p>
    /// <p>When the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> instantiates a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, the context is set automatically.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setContextForObject">setContextForObject</a>(), <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlContext">qmlContext</a>(), and <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlEngine">qmlEngine</a>().</p></div>
    #[inline(always)]
    pub unsafe fn context_for_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QPtr<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_contextForObject(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns the image provider set for <i>providerId</i> if found; otherwise returns <code>nullptr</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlImageProviderBase* QQmlEngine::imageProvider(const QString& id) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#imageProvider">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the image provider set for <i>providerId</i> if found; otherwise returns <code>nullptr</code>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a>.</p></div>
    #[inline(always)]
    pub unsafe fn image_provider(
        &self,
        id: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::Ptr<crate::QQmlImageProviderBase> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_imageProvider(
                self as *const crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(id)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// <p>Returns the list of directories where the engine searches for installed modules in a URL-based directory structure.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QStringList QQmlEngine::importPathList() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#importPathList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the list of directories where the engine searches for installed modules in a URL-based directory structure.</p>
    /// <p>For example, if <code>/opt/MyApp/lib/imports</code> is in the path, then QML that imports <code>com.mycompany.Feature</code> will cause the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to look in <code>/opt/MyApp/lib/imports/com/mycompany/Feature/</code> for the components provided by that module. A <code>qmldir</code> file is required for defining the type version mapping and possibly QML extensions plugins.</p>
    /// <p>By default, the list contains the directory of the application executable, paths specified in the <code>QML2_IMPORT_PATH</code> environment variable, and the builtin <code>Qml2ImportsPath</code> from <a href="http://doc.qt.io/qt-5/qlibraryinfo.html">QLibraryInfo</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#addImportPath">addImportPath</a>() and <a href="http://doc.qt.io/qt-5/qqmlengine.html#setImportPathList">setImportPathList</a>().</p></div>
    #[inline(always)]
    pub unsafe fn import_path_list(&self) -> ::cpp_core::CppBox<::qt_core::QStringList> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_importPathList(self as *const crate::QQmlEngine)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Imports the plugin named <i>filePath</i> with the <i>uri</i> provided. Returns true if the plugin was successfully imported; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlEngine::importPlugin(const QString& filePath, const QString& uri, QList<QQmlError>* errors)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#importPlugin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Imports the plugin named <i>filePath</i> with the <i>uri</i> provided. Returns true if the plugin was successfully imported; otherwise returns false.</p>
    /// <p>On failure and if non-null, the <i>errors</i> list will have any errors which occurred prepended to it.</p>
    /// <p>The plugin has to be a Qt plugin which implements the <a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html">QQmlExtensionPlugin</a> interface.</p></div>
    #[inline(always)]
    pub unsafe fn import_plugin(
        &self,
        file_path: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        uri: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        errors: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QListOfQQmlError>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_importPlugin(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_path)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(uri)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QListOfQQmlError>>::cast_into(errors)
                .as_raw_ptr() as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>Returns the currently set incubation controller, or 0 if no controller has been set.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlIncubationController* QQmlEngine::incubationController() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#incubationController">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the currently set incubation controller, or 0 if no controller has been set.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setIncubationController">setIncubationController</a>().</p></div>
    #[inline(always)]
    pub unsafe fn incubation_controller(&self) -> ::cpp_core::Ptr<crate::QQmlIncubationController> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_incubationController(
                self as *const crate::QQmlEngine,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlEngine::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_metaObject(self as *const crate::QQmlEngine)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Returns the current <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html">QQmlNetworkAccessManagerFactory</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlNetworkAccessManagerFactory* QQmlEngine::networkAccessManagerFactory() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#networkAccessManagerFactory">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the current <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html">QQmlNetworkAccessManagerFactory</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setNetworkAccessManagerFactory">setNetworkAccessManagerFactory</a>().</p></div>
    #[inline(always)]
    pub unsafe fn network_access_manager_factory(
        &self,
    ) -> ::cpp_core::Ptr<crate::QQmlNetworkAccessManagerFactory> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_networkAccessManagerFactory(
                self as *const crate::QQmlEngine,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> with the given <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlEngine::QQmlEngine(QObject* p = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#QQmlEngine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> with the given <i>parent</i>.</p></div>
    #[inline(always)]
    pub unsafe fn new_1a(
        p: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_QQmlEngine(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(p)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Each QML component is instantiated in a <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>. <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>'s are essential for passing data to QML components. In QML, contexts are arranged hierarchically and this hierarchy is managed by the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlEngine::QQmlEngine()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Each QML component is instantiated in a <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>. <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>'s are essential for passing data to QML components. In QML, contexts are arranged hierarchically and this hierarchy is managed by the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p>
    /// <p>Prior to creating any QML components, an application must have created a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to gain access to a QML context. The following example shows how to create a simple Text item.</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html#QQmlEngine">QQmlEngine</a></span> engine;
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a></span> component(<span class="operator">&amp;</span>engine);
    ///   component<span class="operator">.</span>setData(<span class="string">"import QtQuick 2.0\nText { text: \"Hello world!\" }"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span>());
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span>item <span class="operator">=</span> qobject_cast<span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span><span class="operator">&gt;</span>(component<span class="operator">.</span>create());
    ///
    ///   <span class="comment">//add item to view, etc</span>
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///
    /// </pre>
    /// <p>In this case, the Text item will be created in the engine's <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new_0a() -> ::qt_core::QBox<crate::QQmlEngine> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_QQmlEngine1() };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Returns the ownership of <i>object</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QQmlEngine::ObjectOwnership QQmlEngine::objectOwnership(QObject* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#objectOwnership">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the ownership of <i>object</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setObjectOwnership">setObjectOwnership</a>().</p></div>
    #[inline(always)]
    pub unsafe fn object_ownership(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> crate::q_qml_engine::ObjectOwnership {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_objectOwnership(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
        )
    }

    /// <p>Returns the file path where a <a href="http://doc.qt.io/qt-5/qtquick-localstorage-qmlmodule.html">Local Storage</a> database with the identifier <i>databaseName</i> is (or would be) located.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlEngine::offlineStorageDatabaseFilePath(const QString& databaseName) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#offlineStorageDatabaseFilePath">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the file path where a <a href="http://doc.qt.io/qt-5/qtquick-localstorage-qmlmodule.html">Local Storage</a> database with the identifier <i>databaseName</i> is (or would be) located.</p>
    /// <p>This function was introduced in  Qt 5.9.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qtquick-localstorage-qmlmodule.html#opendatabasesync">LocalStorage.openDatabaseSync</a>().</p></div>
    #[inline(always)]
    pub unsafe fn offline_storage_database_file_path(
        &self,
        database_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_offlineStorageDatabaseFilePath(
                self as *const crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(
                    database_name,
                )
                .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This property holds the directory for storing offline user data</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlEngine::offlineStoragePath() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#offlineStoragePath-prop">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This property holds the directory for storing offline user data</p>
    /// <p>Returns the directory where SQL and other offline storage is placed.</p>
    /// <p>The SQL databases created with openDatabase() are stored here.</p>
    /// <p>The default is QML/OfflineStorage in the platform-standard user application data directory.</p>
    /// <p>Note that the path may not currently exist on the filesystem, so callers wanting to <i>create</i> new files at this location should create it first - see <a href="http://doc.qt.io/qt-5/qdir.html#mkpath">QDir::mkpath</a>().</p>
    /// <p><b>Access functions:</b></p>
    /// <div class="table"><table class="alignedsummary">
    /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> QString </td><td class="memItemRight bottomAlign"><span class="name"><b>offlineStoragePath</b></span>() const</td></tr>
    /// <tr><td class="memItemLeft topAlign rightAlign"> void </td><td class="memItemRight bottomAlign"><span class="name"><b>setOfflineStoragePath</b></span>(const QString &amp;<i>dir</i>)</td></tr>
    /// </tbody></table></div></div>
    #[inline(always)]
    pub unsafe fn offline_storage_path(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_offlineStoragePath(
                self as *const crate::QQmlEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns true if warning messages will be output to stderr in addition to being emitted by the <a href="http://doc.qt.io/qt-5/qqmlengine.html#warnings">warnings</a>() signal, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlEngine::outputWarningsToStandardError() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#outputWarningsToStandardError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if warning messages will be output to stderr in addition to being emitted by the <a href="http://doc.qt.io/qt-5/qqmlengine.html#warnings">warnings</a>() signal, otherwise false.</p>
    /// <p>The default value is true.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#setOutputWarningsToStandardError">setOutputWarningsToStandardError</a>().</p></div>
    #[inline(always)]
    pub unsafe fn output_warnings_to_standard_error(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_outputWarningsToStandardError(
            self as *const crate::QQmlEngine,
        )
    }

    /// <p>Returns the list of directories where the engine searches for native plugins for imported modules (referenced in the <code>qmldir</code> file).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QStringList QQmlEngine::pluginPathList() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#pluginPathList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the list of directories where the engine searches for native plugins for imported modules (referenced in the <code>qmldir</code> file).</p>
    /// <p>By default, the list contains only <code>.</code>, i.e. the engine searches in the directory of the <code>qmldir</code> file itself.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#addPluginPath">addPluginPath</a>() and <a href="http://doc.qt.io/qt-5/qqmlengine.html#setPluginPathList">setPluginPathList</a>().</p></div>
    #[inline(always)]
    pub unsafe fn plugin_path_list(&self) -> ::cpp_core::CppBox<::qt_core::QStringList> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_pluginPathList(self as *const crate::QQmlEngine)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlEngine::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_qt_metacall(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlEngine::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_qt_metacast(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            arg1,
        )
    }

    /// <p>Removes the image provider for <i>providerId</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::removeImageProvider(const QString& id)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#removeImageProvider">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the image provider for <i>providerId</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#addImageProvider">addImageProvider</a>() and <a href="http://doc.qt.io/qt-5/qquickimageprovider.html">QQuickImageProvider</a>.</p></div>
    #[inline(always)]
    pub unsafe fn remove_image_provider(
        &self,
        id: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_removeImageProvider(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(id).as_raw_ptr(),
        )
    }

    /// <p>Refreshes all binding expressions that use strings marked for translation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlEngine::retranslate()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#retranslate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Refreshes all binding expressions that use strings marked for translation.</p>
    /// <p>Call this function after you have installed a new translator with <a href="http://doc.qt.io/qt-5/qcoreapplication.html#installTranslator">QCoreApplication::installTranslator</a>, to ensure that your user-interface shows up-to-date translations.</p>
    /// <p><b>Note: </b>Due to a limitation in the implementation, this function refreshes all the engine's bindings, not only those that use strings marked for translation. This may be optimized in a future release.</p><p>This function was introduced in  Qt 5.10.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn retranslate(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_retranslate(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
        )
    }

    /// <p>Returns the engine's root context.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext* QQmlEngine::rootContext() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the engine's root context.</p>
    /// <p>The root context is automatically created by the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>. Data that should be available to all QML component instances instantiated by the engine should be put in the root context.</p>
    /// <p>Additional data that should only be available to a subset of component instances should be added to sub-contexts parented to the root context.</p></div>
    #[inline(always)]
    pub unsafe fn root_context(&self) -> ::qt_core::QPtr<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_rootContext(self as *const crate::QQmlEngine)
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Set the base URL for this engine to <i>url</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setBaseUrl(const QUrl& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setBaseUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set the base URL for this engine to <i>url</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">baseUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_base_url(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setBaseUrl(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg1).as_raw_ptr(),
        )
    }

    /// <p>Sets the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> for the <i>object</i> to <i>context</i>. If the <i>object</i> already has a context, a warning is output, but the context is not changed.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static void QQmlEngine::setContextForObject(QObject* arg1, QQmlContext* arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setContextForObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> for the <i>object</i> to <i>context</i>. If the <i>object</i> already has a context, a warning is output, but the context is not changed.</p>
    /// <p>When the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> instantiates a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, the context is set automatically.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#contextForObject">contextForObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_context_for_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setContextForObject(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg2)
                .as_raw_ptr() as *mut crate::QQmlContext,
        )
    }

    /// <p>Sets <i>paths</i> as the list of directories where the engine searches for installed modules in a URL-based directory structure.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setImportPathList(const QStringList& paths)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setImportPathList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets <i>paths</i> as the list of directories where the engine searches for installed modules in a URL-based directory structure.</p>
    /// <p>By default, the list contains the directory of the application executable, paths specified in the <code>QML2_IMPORT_PATH</code> environment variable, and the builtin <code>Qml2ImportsPath</code> from <a href="http://doc.qt.io/qt-5/qlibraryinfo.html">QLibraryInfo</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#importPathList">importPathList</a>() and <a href="http://doc.qt.io/qt-5/qqmlengine.html#addImportPath">addImportPath</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_import_path_list(
        &self,
        paths: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QStringList>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setImportPathList(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QStringList>>::cast_into(paths)
                .as_raw_ptr(),
        )
    }

    /// <p>Sets the engine's incubation <i>controller</i>. The engine can only have one active controller and it does not take ownership of it.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setIncubationController(QQmlIncubationController* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setIncubationController">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the engine's incubation <i>controller</i>. The engine can only have one active controller and it does not take ownership of it.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#incubationController">incubationController</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_incubation_controller(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlIncubationController>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setIncubationController(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlIncubationController>>::cast_into(
                arg1,
            )
            .as_raw_ptr() as *mut crate::QQmlIncubationController,
        )
    }

    /// <p>Sets the <i>factory</i> to use for creating QNetworkAccessManager(s).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setNetworkAccessManagerFactory">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <i>factory</i> to use for creating QNetworkAccessManager(s).</p>
    /// <p>QNetworkAccessManager is used for all network access by QML. By implementing a factory it is possible to create custom QNetworkAccessManager with specialized caching, proxy and cookie support.</p>
    /// <p>The factory must be set before executing the engine.</p>
    /// <p><b>Note: </b><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> does not take ownership of the factory.</p><p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#networkAccessManagerFactory">networkAccessManagerFactory</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_network_access_manager_factory(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlNetworkAccessManagerFactory>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setNetworkAccessManagerFactory(self as *const crate::QQmlEngine as *mut crate::QQmlEngine, ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlNetworkAccessManagerFactory>>::cast_into(arg1).as_raw_ptr() as *mut crate::QQmlNetworkAccessManagerFactory)
    }

    /// <p>Sets the <i>ownership</i> of <i>object</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static void QQmlEngine::setObjectOwnership(QObject* arg1, QQmlEngine::ObjectOwnership arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setObjectOwnership">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <i>ownership</i> of <i>object</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#objectOwnership">objectOwnership</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_object_ownership(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: crate::q_qml_engine::ObjectOwnership,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setObjectOwnership(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            arg2,
        )
    }

    /// <p>This property holds the directory for storing offline user data</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setOfflineStoragePath(const QString& dir)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#offlineStoragePath-prop">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This property holds the directory for storing offline user data</p>
    /// <p>Returns the directory where SQL and other offline storage is placed.</p>
    /// <p>The SQL databases created with openDatabase() are stored here.</p>
    /// <p>The default is QML/OfflineStorage in the platform-standard user application data directory.</p>
    /// <p>Note that the path may not currently exist on the filesystem, so callers wanting to <i>create</i> new files at this location should create it first - see <a href="http://doc.qt.io/qt-5/qdir.html#mkpath">QDir::mkpath</a>().</p>
    /// <p><b>Access functions:</b></p>
    /// <div class="table"><table class="alignedsummary">
    /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> QString </td><td class="memItemRight bottomAlign"><span class="name"><b>offlineStoragePath</b></span>() const</td></tr>
    /// <tr><td class="memItemLeft topAlign rightAlign"> void </td><td class="memItemRight bottomAlign"><span class="name"><b>setOfflineStoragePath</b></span>(const QString &amp;<i>dir</i>)</td></tr>
    /// </tbody></table></div></div>
    #[inline(always)]
    pub unsafe fn set_offline_storage_path(
        &self,
        dir: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setOfflineStoragePath(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(dir)
                .as_raw_ptr(),
        )
    }

    /// <p>Set whether warning messages will be output to stderr to <i>enabled</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setOutputWarningsToStandardError(bool arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setOutputWarningsToStandardError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set whether warning messages will be output to stderr to <i>enabled</i>.</p>
    /// <p>If <i>enabled</i> is true, any warning messages generated by QML will be output to stderr and emitted by the <a href="http://doc.qt.io/qt-5/qqmlengine.html#warnings">warnings</a>() signal. If <i>enabled</i> is false, only the <a href="http://doc.qt.io/qt-5/qqmlengine.html#warnings">warnings</a>() signal will be emitted. This allows applications to handle warning output themselves.</p>
    /// <p>The default value is true.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#outputWarningsToStandardError">outputWarningsToStandardError</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_output_warnings_to_standard_error(&self, arg1: bool) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setOutputWarningsToStandardError(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            arg1,
        )
    }

    /// <p>Sets the list of directories where the engine searches for native plugins for imported modules (referenced in the <code>qmldir</code> file) to <i>paths</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setPluginPathList(const QStringList& paths)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#setPluginPathList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the list of directories where the engine searches for native plugins for imported modules (referenced in the <code>qmldir</code> file) to <i>paths</i>.</p>
    /// <p>By default, the list contains only <code>.</code>, i.e. the engine searches in the directory of the <code>qmldir</code> file itself.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#pluginPathList">pluginPathList</a>() and <a href="http://doc.qt.io/qt-5/qqmlengine.html#addPluginPath">addPluginPath</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_plugin_path_list(
        &self,
        paths: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QStringList>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setPluginPathList(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QStringList>>::cast_into(paths)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::setUrlInterceptor(QQmlAbstractUrlInterceptor* urlInterceptor)```</span>.
    #[inline(always)]
    pub unsafe fn set_url_interceptor(
        &self,
        url_interceptor: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlAbstractUrlInterceptor>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_setUrlInterceptor(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlAbstractUrlInterceptor>>::cast_into(
                url_interceptor,
            )
            .as_raw_ptr() as *mut crate::QQmlAbstractUrlInterceptor,
        )
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlEngine::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlEngine::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Trims the engine's internal component cache.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlEngine::trimComponentCache()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#trimComponentCache">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Trims the engine's internal component cache.</p>
    /// <p>This function causes the property metadata of any loaded components which are not currently in use to be destroyed.</p>
    /// <p>A component is considered to be in use if there are any extant instances of the component itself, any instances of other components that use the component, or any objects instantiated by any of those components.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#clearComponentCache">clearComponentCache</a>().</p></div>
    #[inline(always)]
    pub unsafe fn trim_component_cache(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_trimComponentCache(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlAbstractUrlInterceptor* QQmlEngine::urlInterceptor() const```</span>.
    #[inline(always)]
    pub unsafe fn url_interceptor(&self) -> ::cpp_core::Ptr<crate::QQmlAbstractUrlInterceptor> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_urlInterceptor(self as *const crate::QQmlEngine)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

/// <p>This class combines a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> and <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to provide a convenient way to load a single QML file. It also exposes some central application functionality to QML, which a C++/QML hybrid application would normally control from C++.</p>
///
/// C++ class: <span style='color: green;'>```QQmlApplicationEngine```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This class combines a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> and <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to provide a convenient way to load a single QML file. It also exposes some central application functionality to QML, which a C++/QML hybrid application would normally control from C++.</p>
/// <p>It can be used like so:</p>
/// <pre class="cpp">
///
///   <span class="preprocessor">#include &lt;QGuiApplication&gt;</span>
///   <span class="preprocessor">#include &lt;QQmlApplicationEngine&gt;</span>
///
///   <span class="type">int</span> main(<span class="type">int</span> argc<span class="operator">,</span> <span class="type">char</span> <span class="operator">*</span>argv<span class="operator">[</span><span class="operator">]</span>)
///   {
/// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qguiapplication.html">QGuiApplication</a></span> app(argc<span class="operator">,</span> argv);
/// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#QQmlApplicationEngine">QQmlApplicationEngine</a></span> engine(<span class="string">"main.qml"</span>);
/// &#32;     <span class="keyword">return</span> app<span class="operator">.</span>exec();
///   }
///
/// </pre>
/// <p>Unlike <a href="http://doc.qt.io/qt-5/qquickview.html">QQuickView</a>, <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> does not automatically create a root window. If you are using visual items from Qt Quick, you will need to place them inside of a <a href="http://doc.qt.io/qt-5/qml-qtquick-window-window.html">Window</a>.</p>
/// <p>You can also use <a href="http://doc.qt.io/qt-5/qcoreapplication.html">QCoreApplication</a> with <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a>, if you are not using any QML modules which require a <a href="http://doc.qt.io/qt-5/qguiapplication.html">QGuiApplication</a> (such as <code>QtQuick</code>).</p>
/// <p>List of configuration changes from a default <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>:</p>
/// <ul>
/// <li>Connecting Qt.<a href="http://doc.qt.io/qt-5/qqmlengine.html#quit">quit</a>() to <a href="http://doc.qt.io/qt-5/qcoreapplication.html#quit">QCoreApplication::quit</a>()</li>
/// <li>Automatically loads translation files from an i18n directory adjacent to the main QML file.</li>
/// <li>Automatically sets an incubation controller if the scene contains a <a href="http://doc.qt.io/qt-5/qquickwindow.html">QQuickWindow</a>.</li>
/// <li>Automatically sets a <code>QQmlFileSelector</code> as the url interceptor, applying file selectors to all QML files and assets.</li>
/// </ul>
/// <p>The engine behavior can be further tweaked by using the inherited methods from <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p></div>
#[repr(C)]
pub struct QQmlApplicationEngine {
    _unused: u8,
}
impl QQmlApplicationEngine {
    /// <p>Loads the root QML file located at <i>url</i>. The object tree defined by the file is created immediately for local file urls. Remote urls are loaded asynchronously, listen to the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#objectCreated">objectCreated</a> signal to determine when the object tree is ready.</p>
    ///
    /// Returns a built-in Qt slot `QQmlApplicationEngine::load` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Loads the root QML file located at <i>url</i>. The object tree defined by the file is created immediately for local file urls. Remote urls are loaded asynchronously, listen to the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#objectCreated">objectCreated</a> signal to determine when the object tree is ready.</p>
    /// <p>If an error occurs, the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#objectCreated">objectCreated</a> signal is emitted with a null pointer as parameter and error messages are printed with <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>.</p></div>
    #[inline(always)]
    pub fn slot_load(&self) -> ::qt_core::Receiver<(*const ::qt_core::QUrl,)> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"1load(QUrl const &)\0"),
            )
        }
    }

    /// <p>Loads the root QML file located at <i>filePath</i>. <i>filePath</i> must be a path to a local file. If <i>filePath</i> is a relative path, it is taken as relative to the application's working directory. The object tree defined by the file is instantiated immediately.</p>
    ///
    /// Returns a built-in Qt slot `QQmlApplicationEngine::load` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Loads the root QML file located at <i>filePath</i>. <i>filePath</i> must be a path to a local file. If <i>filePath</i> is a relative path, it is taken as relative to the application's working directory. The object tree defined by the file is instantiated immediately.</p>
    /// <p>If an error occurs, error messages are printed with <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>.</p></div>
    #[inline(always)]
    pub fn slot_load2(&self) -> ::qt_core::Receiver<(*const ::qt_core::QString,)> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"1load(QString const &)\0"),
            )
        }
    }

    /// <p>Loads the QML given in <i>data</i>. The object tree defined by <i>data</i> is instantiated immediately.</p>
    ///
    /// Returns a built-in Qt slot `QQmlApplicationEngine::loadData` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#loadData">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Loads the QML given in <i>data</i>. The object tree defined by <i>data</i> is instantiated immediately.</p>
    /// <p>If a <i>url</i> is specified it is used as the base url of the component. This affects relative paths within the data and error messages.</p>
    /// <p>If an error occurs, error messages are printed with <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>.</p></div>
    #[inline(always)]
    pub fn slot_load_data(
        &self,
    ) -> ::qt_core::Receiver<(*const ::qt_core::QByteArray, *const ::qt_core::QUrl)> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"1loadData(QByteArray const &,QUrl const &)\0",
                ),
            )
        }
    }

    /// <p>This signal is emitted when an object finishes loading. If loading was successful, <i>object</i> contains a pointer to the loaded object, otherwise the pointer is NULL.</p>
    ///
    /// Returns a built-in Qt signal `QQmlApplicationEngine::objectCreated` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#objectCreated">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This signal is emitted when an object finishes loading. If loading was successful, <i>object</i> contains a pointer to the loaded object, otherwise the pointer is NULL.</p>
    /// <p>The <i>url</i> to the component the <i>object</i> came from is also provided.</p>
    /// <p><b>Note: </b>If the path to the component was provided as a <a href="http://doc.qt.io/qt-5/qstring.html">QString</a> containing a relative path, the <i>url</i> will contain a fully resolved path to the file.</p></div>
    #[inline(always)]
    pub fn object_created(
        &self,
    ) -> ::qt_core::Signal<(*mut ::qt_core::QObject, *const ::qt_core::QUrl)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2objectCreated(QObject *,QUrl const &)\0",
                ),
            )
        }
    }

    /// <p>Loads the root QML file located at <i>url</i>. The object tree defined by the file is created immediately for local file urls. Remote urls are loaded asynchronously, listen to the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#objectCreated">objectCreated</a> signal to determine when the object tree is ready.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlApplicationEngine::load(const QUrl& url)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Loads the root QML file located at <i>url</i>. The object tree defined by the file is created immediately for local file urls. Remote urls are loaded asynchronously, listen to the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#objectCreated">objectCreated</a> signal to determine when the object tree is ready.</p>
    /// <p>If an error occurs, the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#objectCreated">objectCreated</a> signal is emitted with a null pointer as parameter and error messages are printed with <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>.</p></div>
    #[inline(always)]
    pub unsafe fn load_q_url(
        &self,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_load(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
        )
    }

    /// <p>Loads the root QML file located at <i>filePath</i>. <i>filePath</i> must be a path to a local file. If <i>filePath</i> is a relative path, it is taken as relative to the application's working directory. The object tree defined by the file is instantiated immediately.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlApplicationEngine::load(const QString& filePath)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Loads the root QML file located at <i>filePath</i>. <i>filePath</i> must be a path to a local file. If <i>filePath</i> is a relative path, it is taken as relative to the application's working directory. The object tree defined by the file is instantiated immediately.</p>
    /// <p>If an error occurs, error messages are printed with <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>.</p></div>
    #[inline(always)]
    pub unsafe fn load_q_string(
        &self,
        file_path: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_load1(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_path)
                .as_raw_ptr(),
        )
    }

    /// <p>Loads the QML given in <i>data</i>. The object tree defined by <i>data</i> is instantiated immediately.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlApplicationEngine::loadData(const QByteArray& data, const QUrl& url = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#loadData">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Loads the QML given in <i>data</i>. The object tree defined by <i>data</i> is instantiated immediately.</p>
    /// <p>If a <i>url</i> is specified it is used as the base url of the component. This affects relative paths within the data and error messages.</p>
    /// <p>If an error occurs, error messages are printed with <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>.</p></div>
    #[inline(always)]
    pub unsafe fn load_data_2a(
        &self,
        data: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QByteArray>>,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_loadData(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QByteArray>>::cast_into(data)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
        )
    }

    /// <p>Loads the QML given in <i>data</i>. The object tree defined by <i>data</i> is instantiated immediately.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlApplicationEngine::loadData(const QByteArray& data)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#loadData">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Loads the QML given in <i>data</i>. The object tree defined by <i>data</i> is instantiated immediately.</p>
    /// <p>If a <i>url</i> is specified it is used as the base url of the component. This affects relative paths within the data and error messages.</p>
    /// <p>If an error occurs, error messages are printed with <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>.</p></div>
    #[inline(always)]
    pub unsafe fn load_data_1a(
        &self,
        data: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QByteArray>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_loadData1(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QByteArray>>::cast_into(data)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlApplicationEngine::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_metaObject(
                self as *const crate::QQmlApplicationEngine,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> with the given <i>parent</i>. You will have to call <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">load</a>() later in order to load a QML file.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlApplicationEngine::QQmlApplicationEngine(QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#QQmlApplicationEngine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> with the given <i>parent</i>. You will have to call <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">load</a>() later in order to load a QML file.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_object(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_QQmlApplicationEngine(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>url</i>. This is provided as a convenience, and is the same as using the empty constructor and calling load afterwards.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlApplicationEngine::QQmlApplicationEngine(const QUrl& url, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#QQmlApplicationEngine-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>url</i>. This is provided as a convenience, and is the same as using the empty constructor and calling load afterwards.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_url_q_object(
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_QQmlApplicationEngine1(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>filePath</i>, which must be a local file path. If a relative path is given then it will be interpreted as relative to the working directory of the application.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlApplicationEngine::QQmlApplicationEngine(const QString& filePath, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#QQmlApplicationEngine-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>filePath</i>, which must be a local file path. If a relative path is given then it will be interpreted as relative to the working directory of the application.</p>
    /// <p>This is provided as a convenience, and is the same as using the empty constructor and calling load afterwards.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_string_q_object(
        file_path: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_QQmlApplicationEngine2(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_path)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>This class combines a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> and <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to provide a convenient way to load a single QML file. It also exposes some central application functionality to QML, which a C++/QML hybrid application would normally control from C++.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlApplicationEngine::QQmlApplicationEngine()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This class combines a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> and <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to provide a convenient way to load a single QML file. It also exposes some central application functionality to QML, which a C++/QML hybrid application would normally control from C++.</p>
    /// <p>It can be used like so:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="preprocessor">#include &lt;QGuiApplication&gt;</span>
    ///   <span class="preprocessor">#include &lt;QQmlApplicationEngine&gt;</span>
    ///
    ///   <span class="type">int</span> main(<span class="type">int</span> argc<span class="operator">,</span> <span class="type">char</span> <span class="operator">*</span>argv<span class="operator">[</span><span class="operator">]</span>)
    ///   {
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qguiapplication.html">QGuiApplication</a></span> app(argc<span class="operator">,</span> argv);
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#QQmlApplicationEngine">QQmlApplicationEngine</a></span> engine(<span class="string">"main.qml"</span>);
    /// &#32;     <span class="keyword">return</span> app<span class="operator">.</span>exec();
    ///   }
    ///
    /// </pre>
    /// <p>Unlike <a href="http://doc.qt.io/qt-5/qquickview.html">QQuickView</a>, <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> does not automatically create a root window. If you are using visual items from Qt Quick, you will need to place them inside of a <a href="http://doc.qt.io/qt-5/qml-qtquick-window-window.html">Window</a>.</p>
    /// <p>You can also use <a href="http://doc.qt.io/qt-5/qcoreapplication.html">QCoreApplication</a> with <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a>, if you are not using any QML modules which require a <a href="http://doc.qt.io/qt-5/qguiapplication.html">QGuiApplication</a> (such as <code>QtQuick</code>).</p>
    /// <p>List of configuration changes from a default <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>:</p>
    /// <ul>
    /// <li>Connecting Qt.<a href="http://doc.qt.io/qt-5/qqmlengine.html#quit">quit</a>() to <a href="http://doc.qt.io/qt-5/qcoreapplication.html#quit">QCoreApplication::quit</a>()</li>
    /// <li>Automatically loads translation files from an i18n directory adjacent to the main QML file.</li>
    /// <li>Automatically sets an incubation controller if the scene contains a <a href="http://doc.qt.io/qt-5/qquickwindow.html">QQuickWindow</a>.</li>
    /// <li>Automatically sets a <code>QQmlFileSelector</code> as the url interceptor, applying file selectors to all QML files and assets.</li>
    /// </ul>
    /// <p>The engine behavior can be further tweaked by using the inherited methods from <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::qt_core::QBox<crate::QQmlApplicationEngine> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_QQmlApplicationEngine3() };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>url</i>. This is provided as a convenience, and is the same as using the empty constructor and calling load afterwards.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlApplicationEngine::QQmlApplicationEngine(const QUrl& url)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#QQmlApplicationEngine-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>url</i>. This is provided as a convenience, and is the same as using the empty constructor and calling load afterwards.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_url(
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) -> ::qt_core::QBox<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_QQmlApplicationEngine4(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url)
                    .as_raw_ptr(),
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>filePath</i>, which must be a local file path. If a relative path is given then it will be interpreted as relative to the working directory of the application.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlApplicationEngine::QQmlApplicationEngine(const QString& filePath)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#QQmlApplicationEngine-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and loads the QML file at the given <i>filePath</i>, which must be a local file path. If a relative path is given then it will be interpreted as relative to the working directory of the application.</p>
    /// <p>This is provided as a convenience, and is the same as using the empty constructor and calling load afterwards.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_string(
        file_path: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::qt_core::QBox<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_QQmlApplicationEngine5(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_path)
                    .as_raw_ptr(),
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlApplicationEngine::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_qt_metacall(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlApplicationEngine::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_qt_metacast(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            arg1,
        )
    }

    /// <p>Returns a list of all the root objects instantiated by the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a>. This will only contain objects loaded via <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">load</a>() or a convenience constructor.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QObject*> QQmlApplicationEngine::rootObjects()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#rootObjects">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a list of all the root objects instantiated by the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a>. This will only contain objects loaded via <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">load</a>() or a convenience constructor.</p>
    /// <p><b>Note: </b>In Qt versions prior to 5.9, this function is marked as non-<code>const</code>.</p></div>
    #[inline(always)]
    pub unsafe fn root_objects_mut(&self) -> ::cpp_core::CppBox<::qt_core::QListOfQObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_rootObjects(
                self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a list of all the root objects instantiated by the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a>. This will only contain objects loaded via <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">load</a>() or a convenience constructor.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QObject*> QQmlApplicationEngine::rootObjects() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#rootObjects">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a list of all the root objects instantiated by the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a>. This will only contain objects loaded via <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">load</a>() or a convenience constructor.</p>
    /// <p><b>Note: </b>In Qt versions prior to 5.9, this function is marked as non-<code>const</code>.</p></div>
    #[inline(always)]
    pub unsafe fn root_objects(&self) -> ::cpp_core::CppBox<::qt_core::QListOfQObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_rootObjects1(
                self as *const crate::QQmlApplicationEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Sets the <i>initialProperties</i> with which the QML component gets initialized after it gets loaded.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlApplicationEngine::setInitialProperties(const QMap<QString, QVariant>& initialProperties)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#setInitialProperties">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <i>initialProperties</i> with which the QML component gets initialized after it gets loaded.</p>
    /// <p>This function was introduced in  Qt 5.14.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setInitialProperties">QQmlComponent::setInitialProperties</a>, <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#load">QQmlApplicationEngine::load</a>, and <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#loadData">QQmlApplicationEngine::loadData</a>.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(cpp_lib_version = "5.14.0"))
    )]
    #[cfg(any(cpp_lib_version = "5.14.0", feature = "ritual_rustdoc"))]
    pub unsafe fn set_initial_properties(
        &self,
        initial_properties: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_setInitialProperties(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>::cast_into(
                initial_properties,
            )
            .as_raw_ptr(),
        )
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlApplicationEngine::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlApplicationEngine::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_qml_component {
    //! C++ type: <span style='color: green;'>```QQmlComponent```</span>

    /// <p>Specifies whether the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> should load the component immediately, or asynchonously.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlComponent::CompilationMode```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Specifies whether the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> should load the component immediately, or asynchonously.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct CompilationMode(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for CompilationMode {
        fn from(value: ::std::os::raw::c_int) -> Self {
            CompilationMode(value)
        }
    }

    impl From<CompilationMode> for ::std::os::raw::c_int {
        fn from(value: CompilationMode) -> Self {
            value.0
        }
    }

    impl CompilationMode {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl CompilationMode {
        /// Prefer loading/compiling the component immediately, blocking the thread. This is not always possible; for example, remote URLs will always load asynchronously. (C++ enum variant: <span style='color: green;'>```PreferSynchronous = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const PreferSynchronous: crate::q_qml_component::CompilationMode =
            crate::q_qml_component::CompilationMode(0);
        /// Load/compile the component in a background thread. (C++ enum variant: <span style='color: green;'>```Asynchronous = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const Asynchronous: crate::q_qml_component::CompilationMode =
            crate::q_qml_component::CompilationMode(1);
    }

    /// <p>Specifies the loading status of the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a>.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlComponent::Status```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Specifies the loading status of the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a>.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Status(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for Status {
        fn from(value: ::std::os::raw::c_int) -> Self {
            Status(value)
        }
    }

    impl From<Status> for ::std::os::raw::c_int {
        fn from(value: Status) -> Self {
            value.0
        }
    }

    impl Status {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl Status {
        /// This <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> has no data. Call <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>() or <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">setData</a>() to add QML content. (C++ enum variant: <span style='color: green;'>```Null = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const Null: crate::q_qml_component::Status = crate::q_qml_component::Status(0);
        /// This <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> is ready and <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">create</a>() may be called. (C++ enum variant: <span style='color: green;'>```Ready = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const Ready: crate::q_qml_component::Status = crate::q_qml_component::Status(1);
        /// This <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> is loading network data. (C++ enum variant: <span style='color: green;'>```Loading = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const Loading: crate::q_qml_component::Status = crate::q_qml_component::Status(2);
        /// An error has occurred. Call <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#errors">errors</a>() to retrieve a list of <a href="http://doc.qt.io/qt-5/qqmlerror.html">errors</a>. (C++ enum variant: <span style='color: green;'>```Error = 3```</span>)
        #[allow(non_upper_case_globals)]
        pub const Error: crate::q_qml_component::Status = crate::q_qml_component::Status(3);
    }
}
/// <p>Components are reusable, encapsulated QML types with well-defined interfaces.</p>
///
/// C++ class: <span style='color: green;'>```QQmlComponent```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Components are reusable, encapsulated QML types with well-defined interfaces.</p>
/// <p>A <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> instance can be created from a QML file. For example, if there is a <code>main.qml</code> file like this:</p>
/// <pre class="qml">
///
///   import QtQuick 2.0
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qml-qtquick-item.html">Item</a></span> {
/// &#32;     <span class="name">width</span>: <span class="number">200</span>
/// &#32;     <span class="name">height</span>: <span class="number">200</span>
///   }
///
/// </pre>
/// <p>The following code loads this QML file as a component, creates an instance of this component using <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">create</a>(), and then queries the <a href="http://doc.qt.io/qt-5/qml-qtquick-item.html">Item</a>'s <a href="http://doc.qt.io/qt-5/qml-qtquick-item.html#width-prop">width</a> value:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> <span class="operator">*</span>engine <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span>;
///   <span class="type">QQmlComponent</span> component(engine<span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"main.qml"</span>));
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span> <span class="operator">*</span>myObject <span class="operator">=</span> component<span class="operator">.</span>create();
///   <span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span>item <span class="operator">=</span> qobject_cast<span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span><span class="operator">*</span><span class="operator">&gt;</span>(myObject);
///   <span class="type">int</span> width <span class="operator">=</span> item<span class="operator">-</span><span class="operator">&gt;</span>width();  <span class="comment">// width = 200</span>
///
/// </pre>
/// <p>To create instances of a component in code where a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> instance is not available, you can use <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlContext">qmlContext</a>() or <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlEngine">qmlEngine</a>(). For example, in the scenario below, child items are being created within a <a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a> subclass:</p>
/// <pre class="cpp">
///
///   <span class="type">void</span> MyCppItem<span class="operator">::</span>init()
///   {
/// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> <span class="operator">*</span>engine <span class="operator">=</span> qmlEngine(<span class="keyword">this</span>);
/// &#32;     <span class="comment">// Or:</span>
/// &#32;     <span class="comment">// QQmlEngine *engine = qmlContext(this)-&gt;engine();</span>
/// &#32;     <span class="type">QQmlComponent</span> component(engine<span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"MyItem.qml"</span>));
/// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span>childItem <span class="operator">=</span> qobject_cast<span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span><span class="operator">*</span><span class="operator">&gt;</span>(component<span class="operator">.</span>create());
/// &#32;     childItem<span class="operator">-</span><span class="operator">&gt;</span>setParentItem(<span class="keyword">this</span>);
///   }
///
/// </pre>
/// <p>Note that these functions will return <code>null</code> when called inside the constructor of a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> subclass, as the instance will not yet have a context nor engine.</p>
/// <a name="network-components"></a>
/// <h4>Network Components</h4>
/// <p>If the URL passed to <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> is a network resource, or if the QML document references a network resource, the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> has to fetch the network data before it is able to create objects. In this case, the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> will have a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">Loading</a> <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>. An application will have to wait until the component is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">Ready</a> before calling <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>().</p>
/// <p>The following example shows how to load a QML file from a network resource. After creating the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a>, it tests whether the component is loading. If it is, it connects to the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#statusChanged">QQmlComponent::statusChanged</a>() signal and otherwise calls the <code>continueLoading()</code> method directly. Note that <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isLoading">QQmlComponent::isLoading</a>() may be false for a network component if the component has been cached and is ready immediately.</p>
/// <pre class="cpp">
///
///   MyApplication<span class="operator">::</span>MyApplication()
///   {
/// &#32;     <span class="comment">// ...</span>
/// &#32;     component <span class="operator">=</span> <span class="keyword">new</span> <span class="type">QQmlComponent</span>(engine<span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span>(<span class="string">"http://www.example.com/main.qml"</span>));
/// &#32;     <span class="keyword">if</span> (component<span class="operator">-</span><span class="operator">&gt;</span>isLoading())
/// &#32;   &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span><span class="operator">::</span>connect(component<span class="operator">,</span> SIGNAL(statusChanged(<span class="type">QQmlComponent</span><span class="operator">::</span>Status))<span class="operator">,</span>
/// &#32;   &#32;   &#32;   &#32;   &#32;   &#32;      <span class="keyword">this</span><span class="operator">,</span> SLOT(continueLoading()));
/// &#32;     <span class="keyword">else</span>
/// &#32;   &#32;     continueLoading();
///   }
///
///   <span class="type">void</span> MyApplication<span class="operator">::</span>continueLoading()
///   {
/// &#32;     <span class="keyword">if</span> (component<span class="operator">-</span><span class="operator">&gt;</span>isError()) {
/// &#32;   &#32;     <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> component<span class="operator">-</span><span class="operator">&gt;</span>errors();
/// &#32;     } <span class="keyword">else</span> {
/// &#32;   &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span> <span class="operator">*</span>myObject <span class="operator">=</span> component<span class="operator">-</span><span class="operator">&gt;</span>create();
/// &#32;     }
///   }
///
/// </pre></div>
#[repr(C)]
pub struct QQmlComponent {
    _unused: u8,
}
impl QQmlComponent {
    /// <p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>.</p>
    ///
    /// Returns a built-in Qt slot `QQmlComponent::loadUrl` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p></div>
    #[inline(always)]
    pub fn slot_load_url(&self) -> ::qt_core::Receiver<(*const ::qt_core::QUrl,)> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"1loadUrl(QUrl const &)\0"),
            )
        }
    }

    /// <p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    ///
    /// Returns a built-in Qt slot `QQmlComponent::loadUrl` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p></div>
    #[inline(always)]
    pub fn slot_load_url2(
        &self,
    ) -> ::qt_core::Receiver<(
        *const ::qt_core::QUrl,
        crate::q_qml_component::CompilationMode,
    )> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"1loadUrl(QUrl const &,QQmlComponent::CompilationMode)\0",
                ),
            )
        }
    }

    /// <p>Sets the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to use the given QML <i>data</i>. If <i>url</i> is provided, it is used to set the component name and to provide a base path for items resolved by this component.</p>
    ///
    /// Returns a built-in Qt slot `QQmlComponent::setData` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to use the given QML <i>data</i>. If <i>url</i> is provided, it is used to set the component name and to provide a base path for items resolved by this component.</p></div>
    #[inline(always)]
    pub fn slot_set_data(
        &self,
    ) -> ::qt_core::Receiver<(*const ::qt_core::QByteArray, *const ::qt_core::QUrl)> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"1setData(QByteArray const &,QUrl const &)\0",
                ),
            )
        }
    }

    /// <p>Emitted whenever the component's status changes. <i>status</i> will be the new status.</p>
    ///
    /// Returns a built-in Qt signal `QQmlComponent::statusChanged` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#statusChanged">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Emitted whenever the component's status changes. <i>status</i> will be the new status.</p>
    /// <p><b>Note:</b> Notifier signal for property <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>. </p></div>
    #[inline(always)]
    pub fn status_changed(&self) -> ::qt_core::Signal<(crate::q_qml_component::Status,)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2statusChanged(QQmlComponent::Status)\0",
                ),
            )
        }
    }

    /// <p>Emitted whenever the component's loading progress changes. <i>progress</i> will be the current progress between 0.0 (nothing loaded) and 1.0 (finished).</p>
    ///
    /// Returns a built-in Qt signal `QQmlComponent::progressChanged` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#progressChanged">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Emitted whenever the component's loading progress changes. <i>progress</i> will be the current progress between 0.0 (nothing loaded) and 1.0 (finished).</p>
    /// <p><b>Note:</b> Notifier signal for property <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#progress-prop">progress</a>. </p></div>
    #[inline(always)]
    pub fn progress_changed(&self) -> ::qt_core::Signal<(::std::os::raw::c_double,)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"2progressChanged(double)\0"),
            )
        }
    }

    /// <p>This method provides advanced control over component instance creation. In general, programmers should use <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() to create object instances.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual QObject* QQmlComponent::beginCreate(QQmlContext* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#beginCreate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This method provides advanced control over component instance creation. In general, programmers should use <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() to create object instances.</p>
    /// <p>Create an object instance from this component. Returns <code>nullptr</code> if creation failed. <i>publicContext</i> specifies the context within which to create the object instance.</p>
    /// <p>When <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> constructs an instance, it occurs in three steps:</p>
    /// <ol class="1" type="1"><li>The object hierarchy is created, and constant values are assigned.</li>
    /// <li>Property bindings are evaluated for the first time.</li>
    /// <li>If applicable, <a href="http://doc.qt.io/qt-5/qqmlparserstatus.html#componentComplete">QQmlParserStatus::componentComplete</a>() is called on objects.</li>
    /// </ol>
    /// <p>QQmlComponent::beginCreate() differs from <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() in that it only performs step 1. <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#completeCreate">QQmlComponent::completeCreate</a>() must be called to complete steps 2 and 3.</p>
    /// <p>This breaking point is sometimes useful when using attached properties to communicate information to an instantiated component, as it allows their initial values to be configured before property bindings take effect.</p>
    /// <p>The ownership of the returned object instance is transferred to the caller.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#completeCreate">completeCreate</a>() and <a href="http://doc.qt.io/qt-5/qqmlengine.html#ObjectOwnership-enum">QQmlEngine::ObjectOwnership</a>.</p></div>
    #[inline(always)]
    pub unsafe fn begin_create(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_beginCreate(
                self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlContext,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>This method provides advanced control over component instance creation. In general, programmers should use <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() to create a component.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual void QQmlComponent::completeCreate()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#completeCreate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This method provides advanced control over component instance creation. In general, programmers should use <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() to create a component.</p>
    /// <p>This function completes the component creation begun with <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#beginCreate">QQmlComponent::beginCreate</a>() and must be called afterwards.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#beginCreate">beginCreate</a>().</p></div>
    #[inline(always)]
    pub unsafe fn complete_create(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_completeCreate(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
        )
    }

    /// <p>Create an object instance from this component. Returns <code>nullptr</code> if creation failed. <i>context</i> specifies the context within which to create the object instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual QObject* QQmlComponent::create(QQmlContext* context = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an object instance from this component. Returns <code>nullptr</code> if creation failed. <i>context</i> specifies the context within which to create the object instance.</p>
    /// <p>If <i>context</i> is <code>nullptr</code> (the default), it will create the instance in the <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a> of the engine.</p>
    /// <p>The ownership of the returned object instance is transferred to the caller.</p>
    /// <p>If the object being created from this component is a visual item, it must have a visual parent, which can be set by calling <a href="http://doc.qt.io/qt-5/qquickitem.html#parent-prop">QQuickItem::setParentItem</a>(). See <a href="http://doc.qt.io/qt-5/qtquick-visualcanvas-visualparent.html">Concepts - Visual Parent in Qt Quick</a> for more details.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#ObjectOwnership-enum">QQmlEngine::ObjectOwnership</a>.</p></div>
    #[inline(always)]
    pub unsafe fn create_q_qml_context(
        &self,
        context: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_create(
                self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(context)
                    .as_raw_ptr() as *mut crate::QQmlContext,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Create an object instance from this component using the provided <i>incubator</i>. <i>context</i> specifies the context within which to create the object instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlComponent::create(QQmlIncubator& arg1, QQmlContext* context = …, QQmlContext* forContext = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an object instance from this component using the provided <i>incubator</i>. <i>context</i> specifies the context within which to create the object instance.</p>
    /// <p>If <i>context</i> is 0 (the default), it will create the instance in the engine's <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a>.</p>
    /// <p><i>forContext</i> specifies a context that this object creation depends upon. If the <i>forContext</i> is being created asynchronously, and the <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">QQmlIncubator::IncubationMode</a> is <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">QQmlIncubator::AsynchronousIfNested</a>, this object will also be created asynchronously. If <i>forContext</i> is 0 (the default), the <i>context</i> will be used for this decision.</p>
    /// <p>The created object and its creation status are available via the <i>incubator</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a>.</p></div>
    #[inline(always)]
    pub unsafe fn create_q_qml_incubator2_q_qml_context(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlIncubator>>,
        context: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
        for_context: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_create1(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlIncubator>>::cast_into(arg1)
                .as_raw_ptr() as *mut crate::QQmlIncubator,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(context)
                .as_raw_ptr() as *mut crate::QQmlContext,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(for_context)
                .as_raw_ptr() as *mut crate::QQmlContext,
        )
    }

    /// <p>Create an object instance from this component. Returns <code>nullptr</code> if creation failed. <i>context</i> specifies the context within which to create the object instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual QObject* QQmlComponent::create()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an object instance from this component. Returns <code>nullptr</code> if creation failed. <i>context</i> specifies the context within which to create the object instance.</p>
    /// <p>If <i>context</i> is <code>nullptr</code> (the default), it will create the instance in the <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a> of the engine.</p>
    /// <p>The ownership of the returned object instance is transferred to the caller.</p>
    /// <p>If the object being created from this component is a visual item, it must have a visual parent, which can be set by calling <a href="http://doc.qt.io/qt-5/qquickitem.html#parent-prop">QQuickItem::setParentItem</a>(). See <a href="http://doc.qt.io/qt-5/qtquick-visualcanvas-visualparent.html">Concepts - Visual Parent in Qt Quick</a> for more details.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#ObjectOwnership-enum">QQmlEngine::ObjectOwnership</a>.</p></div>
    #[inline(always)]
    pub unsafe fn create(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_create2(
                self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Create an object instance from this component using the provided <i>incubator</i>. <i>context</i> specifies the context within which to create the object instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlComponent::create(QQmlIncubator& arg1, QQmlContext* context = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an object instance from this component using the provided <i>incubator</i>. <i>context</i> specifies the context within which to create the object instance.</p>
    /// <p>If <i>context</i> is 0 (the default), it will create the instance in the engine's <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a>.</p>
    /// <p><i>forContext</i> specifies a context that this object creation depends upon. If the <i>forContext</i> is being created asynchronously, and the <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">QQmlIncubator::IncubationMode</a> is <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">QQmlIncubator::AsynchronousIfNested</a>, this object will also be created asynchronously. If <i>forContext</i> is 0 (the default), the <i>context</i> will be used for this decision.</p>
    /// <p>The created object and its creation status are available via the <i>incubator</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a>.</p></div>
    #[inline(always)]
    pub unsafe fn create_q_qml_incubator_q_qml_context(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlIncubator>>,
        context: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_create3(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlIncubator>>::cast_into(arg1)
                .as_raw_ptr() as *mut crate::QQmlIncubator,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(context)
                .as_raw_ptr() as *mut crate::QQmlContext,
        )
    }

    /// <p>Create an object instance from this component using the provided <i>incubator</i>. <i>context</i> specifies the context within which to create the object instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlComponent::create(QQmlIncubator& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an object instance from this component using the provided <i>incubator</i>. <i>context</i> specifies the context within which to create the object instance.</p>
    /// <p>If <i>context</i> is 0 (the default), it will create the instance in the engine's <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a>.</p>
    /// <p><i>forContext</i> specifies a context that this object creation depends upon. If the <i>forContext</i> is being created asynchronously, and the <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">QQmlIncubator::IncubationMode</a> is <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">QQmlIncubator::AsynchronousIfNested</a>, this object will also be created asynchronously. If <i>forContext</i> is 0 (the default), the <i>context</i> will be used for this decision.</p>
    /// <p>The created object and its creation status are available via the <i>incubator</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a>.</p></div>
    #[inline(always)]
    pub unsafe fn create_q_qml_incubator(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlIncubator>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_create4(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlIncubator>>::cast_into(arg1)
                .as_raw_ptr() as *mut crate::QQmlIncubator,
        )
    }

    /// <p>Create an object instance of this component, and initialize its toplevel properties with <i>initialProperties</i>. <i>context</i> specifies the context where the object instance is to be created.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlComponent::createWithInitialProperties(const QMap<QString, QVariant>& initialProperties, QQmlContext* context = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#createWithInitialProperties">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an object instance of this component, and initialize its toplevel properties with <i>initialProperties</i>. <i>context</i> specifies the context where the object instance is to be created.</p>
    /// <p>This function was introduced in  Qt 5.14.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(cpp_lib_version = "5.14.0"))
    )]
    #[cfg(any(cpp_lib_version = "5.14.0", feature = "ritual_rustdoc"))]
    pub unsafe fn create_with_initial_properties_2a(
        &self,
        initial_properties: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>,
        context: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_createWithInitialProperties(self as *const crate::QQmlComponent as *mut crate::QQmlComponent, ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>::cast_into(initial_properties).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(context).as_raw_ptr() as *mut crate::QQmlContext)
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Create an object instance of this component, and initialize its toplevel properties with <i>initialProperties</i>. <i>context</i> specifies the context where the object instance is to be created.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlComponent::createWithInitialProperties(const QMap<QString, QVariant>& initialProperties)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#createWithInitialProperties">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an object instance of this component, and initialize its toplevel properties with <i>initialProperties</i>. <i>context</i> specifies the context where the object instance is to be created.</p>
    /// <p>This function was introduced in  Qt 5.14.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(cpp_lib_version = "5.14.0"))
    )]
    #[cfg(any(cpp_lib_version = "5.14.0", feature = "ritual_rustdoc"))]
    pub unsafe fn create_with_initial_properties_1a(
        &self,
        initial_properties: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>,
    ) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_createWithInitialProperties1(self as *const crate::QQmlComponent as *mut crate::QQmlComponent, ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>::cast_into(initial_properties).as_raw_ptr())
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> the component was created in. This is only valid for components created directly from QML.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext* QQmlComponent::creationContext() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#creationContext">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> the component was created in. This is only valid for components created directly from QML.</p></div>
    #[inline(always)]
    pub unsafe fn creation_context(&self) -> ::qt_core::QPtr<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_creationContext(
                self as *const crate::QQmlComponent,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> of this component.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* QQmlComponent::engine() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#engine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> of this component.</p>
    /// <p>This function was introduced in  Qt 5.12.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn engine(&self) -> ::qt_core::QPtr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_engine(self as *const crate::QQmlComponent)
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```QString QQmlComponent::errorString() const```</span>.
    #[inline(always)]
    pub unsafe fn error_string(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_errorString(
                self as *const crate::QQmlComponent,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the list of errors that occurred during the last compile or create operation. An empty list is returned if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isError">isError</a>() is not set.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError> QQmlComponent::errors() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#errors">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the list of errors that occurred during the last compile or create operation. An empty list is returned if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isError">isError</a>() is not set.</p></div>
    #[inline(always)]
    pub unsafe fn errors(&self) -> ::cpp_core::CppBox<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_errors(self as *const crate::QQmlComponent)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Error</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlComponent::isError() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Error</a>.</p></div>
    #[inline(always)]
    pub unsafe fn is_error(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_isError(self as *const crate::QQmlComponent)
    }

    /// <p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Loading</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlComponent::isLoading() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isLoading">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Loading</a>.</p></div>
    #[inline(always)]
    pub unsafe fn is_loading(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_isLoading(self as *const crate::QQmlComponent)
    }

    /// <p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Null</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlComponent::isNull() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isNull">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Null</a>.</p></div>
    #[inline(always)]
    pub unsafe fn is_null(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_isNull(self as *const crate::QQmlComponent)
    }

    /// <p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Ready</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlComponent::isReady() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isReady">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>() == <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">QQmlComponent::Ready</a>.</p></div>
    #[inline(always)]
    pub unsafe fn is_ready(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_isReady(self as *const crate::QQmlComponent)
    }

    /// <p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlComponent::loadUrl(const QUrl& url)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p></div>
    #[inline(always)]
    pub unsafe fn load_url_1a(
        &self,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_loadUrl(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
        )
    }

    /// <p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlComponent::loadUrl(const QUrl& url, QQmlComponent::CompilationMode mode)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Load the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the provided <i>url</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p></div>
    #[inline(always)]
    pub unsafe fn load_url_2a(
        &self,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
        mode: crate::q_qml_component::CompilationMode,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_loadUrl1(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
            mode,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlComponent::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_metaObject(
                self as *const crate::QQmlComponent,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QObject* parent = …)```</span>.
    #[inline(always)]
    pub unsafe fn from_q_object(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> with no data and give it the specified <i>engine</i> and <i>parent</i>. Set the data with <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">setData</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> with no data and give it the specified <i>engine</i> and <i>parent</i>. Set the data with <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">setData</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QString& fileName, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_string_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent2(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QString& fileName, QQmlComponent::CompilationMode mode, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-3">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_string_compilation_mode_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        mode: crate::q_qml_component::CompilationMode,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent3(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                    .as_raw_ptr(),
                mode,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QUrl& url, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-4">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_url_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent4(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QUrl& url, QQmlComponent::CompilationMode mode, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-5">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_url_compilation_mode_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
        mode: crate::q_qml_component::CompilationMode,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent5(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url)
                    .as_raw_ptr(),
                mode,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Components are reusable, encapsulated QML types with well-defined interfaces.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Components are reusable, encapsulated QML types with well-defined interfaces.</p>
    /// <p>A <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> instance can be created from a QML file. For example, if there is a <code>main.qml</code> file like this:</p>
    /// <pre class="qml">
    ///
    ///   import QtQuick 2.0
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qml-qtquick-item.html">Item</a></span> {
    /// &#32;     <span class="name">width</span>: <span class="number">200</span>
    /// &#32;     <span class="name">height</span>: <span class="number">200</span>
    ///   }
    ///
    /// </pre>
    /// <p>The following code loads this QML file as a component, creates an instance of this component using <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">create</a>(), and then queries the <a href="http://doc.qt.io/qt-5/qml-qtquick-item.html">Item</a>'s <a href="http://doc.qt.io/qt-5/qml-qtquick-item.html#width-prop">width</a> value:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> <span class="operator">*</span>engine <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span>;
    ///   <span class="type">QQmlComponent</span> component(engine<span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"main.qml"</span>));
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span> <span class="operator">*</span>myObject <span class="operator">=</span> component<span class="operator">.</span>create();
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span>item <span class="operator">=</span> qobject_cast<span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span><span class="operator">*</span><span class="operator">&gt;</span>(myObject);
    ///   <span class="type">int</span> width <span class="operator">=</span> item<span class="operator">-</span><span class="operator">&gt;</span>width();  <span class="comment">// width = 200</span>
    ///
    /// </pre>
    /// <p>To create instances of a component in code where a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> instance is not available, you can use <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlContext">qmlContext</a>() or <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlEngine">qmlEngine</a>(). For example, in the scenario below, child items are being created within a <a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a> subclass:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type">void</span> MyCppItem<span class="operator">::</span>init()
    ///   {
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> <span class="operator">*</span>engine <span class="operator">=</span> qmlEngine(<span class="keyword">this</span>);
    /// &#32;     <span class="comment">// Or:</span>
    /// &#32;     <span class="comment">// QQmlEngine *engine = qmlContext(this)-&gt;engine();</span>
    /// &#32;     <span class="type">QQmlComponent</span> component(engine<span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"MyItem.qml"</span>));
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span> <span class="operator">*</span>childItem <span class="operator">=</span> qobject_cast<span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qquickitem.html">QQuickItem</a></span><span class="operator">*</span><span class="operator">&gt;</span>(component<span class="operator">.</span>create());
    /// &#32;     childItem<span class="operator">-</span><span class="operator">&gt;</span>setParentItem(<span class="keyword">this</span>);
    ///   }
    ///
    /// </pre>
    /// <p>Note that these functions will return <code>null</code> when called inside the constructor of a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> subclass, as the instance will not yet have a context nor engine.</p>
    /// <a name="network-components"></a>
    /// <h4>Network Components</h4>
    /// <p>If the URL passed to <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> is a network resource, or if the QML document references a network resource, the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> has to fetch the network data before it is able to create objects. In this case, the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> will have a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">Loading</a> <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">status</a>. An application will have to wait until the component is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">Ready</a> before calling <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>().</p>
    /// <p>The following example shows how to load a QML file from a network resource. After creating the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a>, it tests whether the component is loading. If it is, it connects to the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#statusChanged">QQmlComponent::statusChanged</a>() signal and otherwise calls the <code>continueLoading()</code> method directly. Note that <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#isLoading">QQmlComponent::isLoading</a>() may be false for a network component if the component has been cached and is ready immediately.</p>
    /// <pre class="cpp">
    ///
    ///   MyApplication<span class="operator">::</span>MyApplication()
    ///   {
    /// &#32;     <span class="comment">// ...</span>
    /// &#32;     component <span class="operator">=</span> <span class="keyword">new</span> <span class="type">QQmlComponent</span>(engine<span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span>(<span class="string">"http://www.example.com/main.qml"</span>));
    /// &#32;     <span class="keyword">if</span> (component<span class="operator">-</span><span class="operator">&gt;</span>isLoading())
    /// &#32;   &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span><span class="operator">::</span>connect(component<span class="operator">,</span> SIGNAL(statusChanged(<span class="type">QQmlComponent</span><span class="operator">::</span>Status))<span class="operator">,</span>
    /// &#32;   &#32;   &#32;   &#32;   &#32;   &#32;      <span class="keyword">this</span><span class="operator">,</span> SLOT(continueLoading()));
    /// &#32;     <span class="keyword">else</span>
    /// &#32;   &#32;     continueLoading();
    ///   }
    ///
    ///   <span class="type">void</span> MyApplication<span class="operator">::</span>continueLoading()
    ///   {
    /// &#32;     <span class="keyword">if</span> (component<span class="operator">-</span><span class="operator">&gt;</span>isError()) {
    /// &#32;   &#32;     <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> component<span class="operator">-</span><span class="operator">&gt;</span>errors();
    /// &#32;     } <span class="keyword">else</span> {
    /// &#32;   &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span> <span class="operator">*</span>myObject <span class="operator">=</span> component<span class="operator">-</span><span class="operator">&gt;</span>create();
    /// &#32;     }
    ///   }
    ///
    /// </pre></div>
    #[inline(always)]
    pub unsafe fn new() -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent6() };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> with no data and give it the specified <i>engine</i> and <i>parent</i>. Set the data with <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">setData</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> with no data and give it the specified <i>engine</i> and <i>parent</i>. Set the data with <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">setData</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent7(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QString& fileName)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_string(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent8(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                    .as_raw_ptr(),
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QString& fileName, QQmlComponent::CompilationMode mode)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-3">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>fileName</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_string_compilation_mode(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        mode: crate::q_qml_component::CompilationMode,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent9(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                    .as_raw_ptr(),
                mode,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QUrl& url)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-4">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_url(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent10(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url)
                    .as_raw_ptr(),
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlComponent::QQmlComponent(QQmlEngine* arg1, const QUrl& url, QQmlComponent::CompilationMode mode)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#QQmlComponent-5">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> from the given <i>url</i> and give it the specified <i>parent</i> and <i>engine</i>. If <i>mode</i> is <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#CompilationMode-enum">Asynchronous</a>, the component will be loaded and compiled asynchronously.</p>
    /// <p>Ensure that the URL provided is full and correct, in particular, use <a href="http://doc.qt.io/qt-5/qurl.html#fromLocalFile">QUrl::fromLocalFile</a>() when loading a file from the local filesystem.</p>
    /// <p>Relative paths will be resolved against <a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl()</a>, which is the current working directory unless specified.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_url_compilation_mode(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
        mode: crate::q_qml_component::CompilationMode,
    ) -> ::qt_core::QBox<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_QQmlComponent11(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url)
                    .as_raw_ptr(),
                mode,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>The progress of loading the component, from 0.0 (nothing loaded) to 1.0 (finished).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```double QQmlComponent::progress() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#progress-prop">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The progress of loading the component, from 0.0 (nothing loaded) to 1.0 (finished).</p>
    /// <p><b>Access functions:</b></p>
    /// <div class="table"><table class="alignedsummary">
    /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> qreal </td><td class="memItemRight bottomAlign"><span class="name"><b>progress</b></span>() const</td></tr>
    /// </tbody></table></div>
    /// <p><b>Notifier signal:</b></p>
    /// <div class="table"><table class="alignedsummary">
    /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> void </td><td class="memItemRight bottomAlign"><span class="name"><b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#progressChanged">progressChanged</a></b></span>(qreal <i>progress</i>)</td></tr>
    /// </tbody></table></div></div>
    #[inline(always)]
    pub unsafe fn progress(&self) -> ::std::os::raw::c_double {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_progress(self as *const crate::QQmlComponent)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlComponent::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_qt_metacall(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlComponent::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_qt_metacast(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            arg1,
        )
    }

    /// <p>Sets the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to use the given QML <i>data</i>. If <i>url</i> is provided, it is used to set the component name and to provide a base path for items resolved by this component.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[slot] void QQmlComponent::setData(const QByteArray& arg1, const QUrl& baseUrl)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> to use the given QML <i>data</i>. If <i>url</i> is provided, it is used to set the component name and to provide a base path for items resolved by this component.</p></div>
    #[inline(always)]
    pub unsafe fn set_data(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QByteArray>>,
        base_url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_setData(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QByteArray>>::cast_into(arg1)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(base_url)
                .as_raw_ptr(),
        )
    }

    /// <p>Set toplevel <i>properties</i> of the <i>component</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlComponent::setInitialProperties(QObject* component, const QMap<QString, QVariant>& properties)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setInitialProperties">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set toplevel <i>properties</i> of the <i>component</i>.</p>
    /// <p>This method provides advanced control over component instance creation. In general, programmers should use <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#createWithInitialProperties">QQmlComponent::createWithInitialProperties</a> to create a component.</p>
    /// <p>Use this method after <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#beginCreate">beginCreate</a> and before <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#completeCreate">completeCreate</a> has been called. If a provided property does not exist, a warning is issued.</p>
    /// <p>This function was introduced in  Qt 5.14.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(cpp_lib_version = "5.14.0"))
    )]
    #[cfg(any(cpp_lib_version = "5.14.0", feature = "ritual_rustdoc"))]
    pub unsafe fn set_initial_properties(
        &self,
        component: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        properties: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_setInitialProperties(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(component)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QMapOfQStringQVariant>>::cast_into(
                properties,
            )
            .as_raw_ptr(),
        )
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// <p>The component's current <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">status</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlComponent::Status QQmlComponent::status() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#status-prop">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The component's current <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#Status-enum">status</a>.</p>
    /// <p><b>Access functions:</b></p>
    /// <div class="table"><table class="alignedsummary">
    /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> QQmlComponent::Status </td><td class="memItemRight bottomAlign"><span class="name"><b>status</b></span>() const</td></tr>
    /// </tbody></table></div>
    /// <p><b>Notifier signal:</b></p>
    /// <div class="table"><table class="alignedsummary">
    /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> void </td><td class="memItemRight bottomAlign"><span class="name"><b><a href="http://doc.qt.io/qt-5/qqmlcomponent.html#statusChanged">statusChanged</a></b></span>(QQmlComponent::Status <i>status</i>)</td></tr>
    /// </tbody></table></div></div>
    #[inline(always)]
    pub unsafe fn status(&self) -> crate::q_qml_component::Status {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_status(self as *const crate::QQmlComponent)
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlComponent::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlComponent::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>The component URL. This is the URL passed to either the constructor, or the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>(), or <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">setData</a>() methods.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QUrl QQmlComponent::url() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#url-prop">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The component URL. This is the URL passed to either the constructor, or the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#loadUrl">loadUrl</a>(), or <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#setData">setData</a>() methods.</p>
    /// <p><b>Access functions:</b></p>
    /// <div class="table"><table class="alignedsummary">
    /// <tbody><tr><td class="memItemLeft topAlign rightAlign"> QUrl </td><td class="memItemRight bottomAlign"><span class="name"><b>url</b></span>() const</td></tr>
    /// </tbody></table></div></div>
    #[inline(always)]
    pub unsafe fn url(&self) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_url(self as *const crate::QQmlComponent) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_qml_context {
    //! C++ type: <span style='color: green;'>```QQmlContext```</span>

    /// <p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p>
    ///
    /// C++ class: <span style='color: green;'>```QQmlContext::PropertyPair```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext-propertypair.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p></div>
    #[repr(C)]
    pub struct PropertyPair {
        _unused: u8,
    }
    impl PropertyPair {
        /// <p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair& QQmlContext::PropertyPair::operator=(const QQmlContext::PropertyPair& other)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qqmlcontext-propertypair.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p></div>
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn copy_from(
            &self,
            other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
        ) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_operator_(self as *const crate::q_qml_context::PropertyPair as *mut crate::q_qml_context::PropertyPair, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(other).as_raw_ptr())
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// Returns a reference to the <span style='color: green;'>```name```</span> field.
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn name(&self) -> ::cpp_core::Ref<::qt_core::QString> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_name(
                    self as *const crate::q_qml_context::PropertyPair,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QString)
                .expect("attempted to construct a null Ref")
        }

        /// Returns a mutable reference to the <span style='color: green;'>```name```</span> field.
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn name_mut(&self) -> ::cpp_core::Ref<::qt_core::QString> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_name_mut(
                    self as *const crate::q_qml_context::PropertyPair
                        as *mut crate::q_qml_context::PropertyPair,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlContext::PropertyPair::PropertyPair()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qqmlcontext-propertypair.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p></div>
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn new() -> ::cpp_core::CppBox<crate::q_qml_context::PropertyPair> {
            let ffi_result =
                { crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_PropertyPair() };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlContext::PropertyPair::PropertyPair(const QQmlContext::PropertyPair& other)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qqmlcontext-propertypair.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p></div>
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn new_copy(
            other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
        ) -> ::cpp_core::CppBox<crate::q_qml_context::PropertyPair> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_PropertyPair1(::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(other).as_raw_ptr())
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Sets the value of the <span style='color: green;'>```name```</span> field.
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn set_name(
            &self,
            value: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        ) {
            crate::__ffi::ctr_qt_qml_ffi_set_QQmlContext_PropertyPair_name(
                self as *const crate::q_qml_context::PropertyPair
                    as *mut crate::q_qml_context::PropertyPair,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(value)
                    .as_raw_ptr(),
            )
        }

        /// Sets the value of the <span style='color: green;'>```value```</span> field.
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn set_value(
            &self,
            value: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
        ) {
            crate::__ffi::ctr_qt_qml_ffi_set_QQmlContext_PropertyPair_value(
                self as *const crate::q_qml_context::PropertyPair
                    as *mut crate::q_qml_context::PropertyPair,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(value)
                    .as_raw_ptr(),
            )
        }

        /// Returns a reference to the <span style='color: green;'>```value```</span> field.
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn value(&self) -> ::cpp_core::Ref<::qt_core::QVariant> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_value(
                    self as *const crate::q_qml_context::PropertyPair,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QVariant)
                .expect("attempted to construct a null Ref")
        }

        /// Returns a mutable reference to the <span style='color: green;'>```value```</span> field.
        #[inline(always)]
        #[cfg_attr(
            feature = "ritual_rustdoc_nightly",
            doc(cfg(any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            )))
        )]
        #[cfg(any(
            any(
                cpp_lib_version = "5.13.0",
                cpp_lib_version = "5.11.3",
                cpp_lib_version = "5.12.2",
                cpp_lib_version = "5.14.0"
            ),
            feature = "ritual_rustdoc"
        ))]
        pub unsafe fn value_mut(&self) -> ::cpp_core::Ref<::qt_core::QVariant> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_value_mut(
                    self as *const crate::q_qml_context::PropertyPair
                        as *mut crate::q_qml_context::PropertyPair,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    impl ::cpp_core::CppDeletable for crate::q_qml_context::PropertyPair {
        /// <p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlContext::PropertyPair::~PropertyPair()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qqmlcontext-propertypair.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This struct contains a property name and a property value. It is used as a parameter for the <code>setContextProperties</code> function.</p></div>
        #[inline(always)]
        unsafe fn delete(&self) {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_PropertyPair_dPropertyPair(
                self as *const crate::q_qml_context::PropertyPair
                    as *mut crate::q_qml_context::PropertyPair,
            )
        }
    }
}
/// <p>Contexts allow data to be exposed to the QML components instantiated by the QML engine.</p>
///
/// C++ class: <span style='color: green;'>```QQmlContext```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlcontext.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Contexts allow data to be exposed to the QML components instantiated by the QML engine.</p>
/// <p>Each <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> contains a set of properties, distinct from its <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> properties, that allow data to be explicitly bound to a context by name. The context properties are defined and updated by calling <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">QQmlContext::setContextProperty</a>(). The following example shows a Qt model being bound to a context and then accessed from a QML file.</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> engine;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qstringlistmodel.html">QStringListModel</a></span> modelData;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span> <span class="operator">*</span>context <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span>(engine<span class="operator">.</span>rootContext());
///   context<span class="operator">-</span><span class="operator">&gt;</span>setContextProperty(<span class="string">"myModel"</span><span class="operator">,</span> <span class="operator">&amp;</span>modelData);
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a></span> component(<span class="operator">&amp;</span>engine);
///   component<span class="operator">.</span>setData(<span class="string">"import QtQuick 2.0\nListView { model: myModel }"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span>());
///   <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span> <span class="operator">*</span>window <span class="operator">=</span> component<span class="operator">.</span>create(context);
///
/// </pre>
/// <p>Note it is the responsibility of the creator to delete any <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> it constructs. If the <code>context</code> object in the example is no longer needed when the <code>window</code> component instance is destroyed, the <code>context</code> must be destroyed explicitly. The simplest way to ensure this is to set <code>window</code> as the parent of <code>context</code>.</p>
/// <p>To simplify binding and maintaining larger data sets, a context object can be set on a <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>. All the properties of the context object are available by name in the context, as though they were all individually added through calls to <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">QQmlContext::setContextProperty</a>(). Changes to the property's values are detected through the property's notify signal. Setting a context object is both faster and easier than manually adding and maintaining context property values.</p>
/// <p>The following example has the same effect as the previous one, but it uses a context object.</p>
/// <pre class="cpp">
///
///   <span class="keyword">class</span> MyDataSet : <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span> {
/// &#32;     <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
/// &#32;     Q_PROPERTY(<span class="type"><a href="http://doc.qt.io/qt-5/qabstractitemmodel.html">QAbstractItemModel</a></span> <span class="operator">*</span>myModel READ model NOTIFY modelChanged)
/// &#32;     <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
///   };
///
///   MyDataSet myDataSet;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> engine;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span> <span class="operator">*</span>context <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span>(engine<span class="operator">.</span>rootContext());
///   context<span class="operator">-</span><span class="operator">&gt;</span>setContextObject(<span class="operator">&amp;</span>myDataSet);
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a></span> component(<span class="operator">&amp;</span>engine);
///   component<span class="operator">.</span>setData(<span class="string">"import QtQuick 2.0\nListView { model: myModel }"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span>());
///   component<span class="operator">.</span>create(context);
///
/// </pre>
/// <p>All properties added explicitly by <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">QQmlContext::setContextProperty</a>() take precedence over the context object's properties.</p>
/// <a name="the-context-hierarchy"></a>
/// <h4>The Context Hierarchy</h4>
/// <p>Contexts form a hierarchy. The root of this hierarchy is the QML engine's <a href="http://doc.qt.io/qt-5/qqmlengine.html#rootContext">root context</a>. Child contexts inherit the context properties of their parents; if a child context sets a context property that already exists in its parent, the new context property overrides that of the parent.</p>
/// <p>The following example defines two contexts - <code>context1</code> and <code>context2</code>. The second context overrides the "b" context property inherited from the first with a new value.</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> engine;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span> <span class="operator">*</span>context1 <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span>(engine<span class="operator">.</span>rootContext());
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span> <span class="operator">*</span>context2 <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">QQmlContext</a></span>(context1);
///
///   context1<span class="operator">-</span><span class="operator">&gt;</span>setContextProperty(<span class="string">"a"</span><span class="operator">,</span> <span class="number">12</span>);
///   context1<span class="operator">-</span><span class="operator">&gt;</span>setContextProperty(<span class="string">"b"</span><span class="operator">,</span> <span class="number">12</span>);
///
///   context2<span class="operator">-</span><span class="operator">&gt;</span>setContextProperty(<span class="string">"b"</span><span class="operator">,</span> <span class="number">15</span>);
///
/// </pre>
/// <p>While QML objects instantiated in a context are not strictly owned by that context, their bindings are. If a context is destroyed, the property bindings of outstanding QML objects will stop evaluating.</p>
/// <p><b>Warning:</b> Setting the context object or adding new context properties after an object has been created in that context is an expensive operation (essentially forcing all bindings to reevaluate). Thus whenever possible you should complete "setup" of the context before using it to create any objects.</p></div>
#[repr(C)]
pub struct QQmlContext {
    _unused: u8,
}
impl QQmlContext {
    /// <p>Returns the base url of the component, or the containing component if none is set.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QUrl QQmlContext::baseUrl() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#baseUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the base url of the component, or the containing component if none is set.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcontext.html#setBaseUrl">setBaseUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn base_url(&self) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlContext_baseUrl(self as *const crate::QQmlContext) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Return the context object, or 0 if there is no context object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlContext::contextObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#contextObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the context object, or 0 if there is no context object.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextObject">setContextObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn context_object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_contextObject(
                self as *const crate::QQmlContext,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns the value of the <i>name</i> property for this context as a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant QQmlContext::contextProperty(const QString& arg1) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#contextProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value of the <i>name</i> property for this context as a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">setContextProperty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn context_property(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_contextProperty(
                self as *const crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Return the context's <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>, or 0 if the context has no <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> or the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> was destroyed.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* QQmlContext::engine() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#engine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the context's <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>, or 0 if the context has no <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> or the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> was destroyed.</p></div>
    #[inline(always)]
    pub unsafe fn engine(&self) -> ::qt_core::QPtr<crate::QQmlEngine> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlContext_engine(self as *const crate::QQmlContext) };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns whether the context is valid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlContext::isValid() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#isValid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns whether the context is valid.</p>
    /// <p>To be valid, a context must have a engine, and it's <a href="http://doc.qt.io/qt-5/qqmlcontext.html#contextObject">contextObject</a>(), if any, must not have been deleted.</p></div>
    #[inline(always)]
    pub unsafe fn is_valid(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_isValid(self as *const crate::QQmlContext)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlContext::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_metaObject(self as *const crate::QQmlContext)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Returns the name of <i>object</i> in this context, or an empty string if <i>object</i> is not named in the context. Objects are named by <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">setContextProperty</a>(), or by ids in the case of QML created contexts.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlContext::nameForObject(QObject* arg1) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#nameForObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the name of <i>object</i> in this context, or an empty string if <i>object</i> is not named in the context. Objects are named by <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">setContextProperty</a>(), or by ids in the case of QML created contexts.</p>
    /// <p>If the object has multiple names, the first is returned.</p></div>
    #[inline(always)]
    pub unsafe fn name_for_object(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_nameForObject(
                self as *const crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> as a child of <i>engine</i>'s root context, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlContext::QQmlContext(QQmlEngine* parent, QObject* objParent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> as a child of <i>engine</i>'s root context, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_object(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        obj_parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_QQmlContext(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(parent)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(obj_parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> with the given <i>parentContext</i>, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlContext::QQmlContext(QQmlContext* parent, QObject* objParent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> with the given <i>parentContext</i>, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_context_q_object(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
        obj_parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_QQmlContext1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(parent)
                    .as_raw_ptr() as *mut crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(obj_parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> as a child of <i>engine</i>'s root context, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlContext::QQmlContext(QQmlEngine* parent)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> as a child of <i>engine</i>'s root context, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_engine(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::qt_core::QBox<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_QQmlContext3(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(parent)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> with the given <i>parentContext</i>, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlContext::QQmlContext(QQmlContext* parent)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#QQmlContext-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> with the given <i>parentContext</i>, and the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> <i>parent</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_context(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::qt_core::QBox<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_QQmlContext4(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(parent)
                    .as_raw_ptr() as *mut crate::QQmlContext,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Return the context's parent <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>, or 0 if this context has no parent or if the parent has been destroyed.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext* QQmlContext::parentContext() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#parentContext">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the context's parent <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>, or 0 if this context has no parent or if the parent has been destroyed.</p></div>
    #[inline(always)]
    pub unsafe fn parent_context(&self) -> ::qt_core::QPtr<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_parentContext(
                self as *const crate::QQmlContext,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlContext::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_qt_metacall(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlContext::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_qt_metacast(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
            arg1,
        )
    }

    /// <p>Resolves the URL <i>src</i> relative to the URL of the containing component.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QUrl QQmlContext::resolvedUrl(const QUrl& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#resolvedUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Resolves the URL <i>src</i> relative to the URL of the containing component.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#baseUrl">QQmlEngine::baseUrl</a>() and <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setBaseUrl">setBaseUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn resolved_url(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlContext_resolvedUrl(
                self as *const crate::QQmlContext as *mut crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Explicitly sets the url <a href="http://doc.qt.io/qt-5/qqmlcontext.html#resolvedUrl">resolvedUrl</a>() will use for relative references to <i>baseUrl</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlContext::setBaseUrl(const QUrl& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setBaseUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Explicitly sets the url <a href="http://doc.qt.io/qt-5/qqmlcontext.html#resolvedUrl">resolvedUrl</a>() will use for relative references to <i>baseUrl</i>.</p>
    /// <p>Calling this function will override the url of the containing component used by default.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcontext.html#baseUrl">baseUrl</a>() and <a href="http://doc.qt.io/qt-5/qqmlcontext.html#resolvedUrl">resolvedUrl</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_base_url(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_setBaseUrl(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg1).as_raw_ptr(),
        )
    }

    /// <p>Set the context <i>object</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlContext::setContextObject(QObject* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set the context <i>object</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcontext.html#contextObject">contextObject</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_context_object(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_setContextObject(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
        )
    }

    /// <p>Set a batch of <i>properties</i> on this context.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlContext::setContextProperties(const QVector<QQmlContext::PropertyPair>& properties)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperties">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set a batch of <i>properties</i> on this context.</p>
    /// <p>Setting all properties in one batch avoids unnecessary refreshing expressions, and is therefore recommended instead of calling <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">setContextProperty</a>() for each individual property.</p>
    /// <p>This function was introduced in  Qt 5.11.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">QQmlContext::setContextProperty</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn set_context_properties(
        &self,
        properties: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QVectorOfPropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_setContextProperties(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QVectorOfPropertyPair>>::cast_into(
                properties,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>Set the <i>value</i> of the <i>name</i> property on this context.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlContext::setContextProperty(const QString& arg1, QObject* arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set the <i>value</i> of the <i>name</i> property on this context.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> does <b>not</b> take ownership of <i>value</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlcontext.html#contextProperty">contextProperty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_context_property_q_string_q_object(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_setContextProperty(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg1)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg2)
                .as_raw_ptr() as *mut ::qt_core::QObject,
        )
    }

    /// <p>Set a the <i>value</i> of the <i>name</i> property on this context.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlContext::setContextProperty(const QString& arg1, const QVariant& arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#setContextProperty-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set a the <i>value</i> of the <i>name</i> property on this context.</p></div>
    #[inline(always)]
    pub unsafe fn set_context_property_q_string_q_variant(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_setContextProperty1(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg1)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(arg2)
                .as_raw_ptr(),
        )
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlContext_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlContext::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlContext_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlContext::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlContext_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p><a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is used to create <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> properties that accept a script "assignment" from QML.</p>
///
/// C++ class: <span style='color: green;'>```QQmlScriptString```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is used to create <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> properties that accept a script "assignment" from QML.</p>
/// <p>Normally, the following QML would result in a binding being established for the <code>script</code> property; i.e. <code>script</code> would be assigned the value obtained from running <code>myObj.value = Math.max(myValue, 100)</code></p>
/// <pre class="qml">
///
///   <span class="type">MyType</span> {
/// &#32;     <span class="name">script</span>: <span class="name">myObj</span>.<span class="name">value</span> <span class="operator">=</span> <span class="name">Math</span>.<span class="name">max</span>(<span class="name">myValue</span>, <span class="number">100</span>)
///   }
///
/// </pre>
/// <p>If instead the property had a type of <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a>, the script itself -- <i>myObj.value = Math.max(myValue, 100)</i> -- would be passed to the <code>script</code> property and the class could choose how to handle it. Typically, the class will evaluate the script at some later time using a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a>.</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a></span> expr(scriptString);
///   expr<span class="operator">.</span>evaluate();
///
/// </pre></div>
#[repr(C)]
pub struct QQmlScriptString {
    _unused: u8,
}
impl QQmlScriptString {
    /// <p>If the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is a boolean literal, returns the boolean value and sets <i>ok</i> to true. Otherwise returns false and sets <i>ok</i> to false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlScriptString::booleanLiteral(bool* ok) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#booleanLiteral">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>If the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is a boolean literal, returns the boolean value and sets <i>ok</i> to true. Otherwise returns false and sets <i>ok</i> to false.</p></div>
    #[inline(always)]
    pub unsafe fn boolean_literal(&self, ok: *mut bool) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_booleanLiteral(
            self as *const crate::QQmlScriptString,
            ok,
        )
    }

    /// <p>Assigns <i>other</i> to this.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlScriptString& QQmlScriptString::operator=(const QQmlScriptString& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns <i>other</i> to this.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlScriptString>>,
    ) -> ::cpp_core::Ref<crate::QQmlScriptString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_operator_(
                self as *const crate::QQmlScriptString as *mut crate::QQmlScriptString,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlScriptString>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns whether the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is empty.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlScriptString::isEmpty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#isEmpty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns whether the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is empty.</p></div>
    #[inline(always)]
    pub unsafe fn is_empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_isEmpty(
            self as *const crate::QQmlScriptString,
        )
    }

    /// <p>Returns whether the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is the <code>null</code> literal.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlScriptString::isNullLiteral() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#isNullLiteral">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns whether the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is the <code>null</code> literal.</p></div>
    #[inline(always)]
    pub unsafe fn is_null_literal(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_isNullLiteral(
            self as *const crate::QQmlScriptString,
        )
    }

    /// <p>Returns whether the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is the <code>undefined</code> literal.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlScriptString::isUndefinedLiteral() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#isUndefinedLiteral">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns whether the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is the <code>undefined</code> literal.</p></div>
    #[inline(always)]
    pub unsafe fn is_undefined_literal(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_isUndefinedLiteral(
            self as *const crate::QQmlScriptString,
        )
    }

    /// <p>Constructs an empty instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlScriptString::QQmlScriptString()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#QQmlScriptString">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an empty instance.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QQmlScriptString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_QQmlScriptString() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Copies <i>other</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlScriptString::QQmlScriptString(const QQmlScriptString& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#QQmlScriptString-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Copies <i>other</i>.</p></div>
    #[inline(always)]
    pub unsafe fn new_copy(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlScriptString>>,
    ) -> ::cpp_core::CppBox<crate::QQmlScriptString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_QQmlScriptString1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlScriptString>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>If the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is a number literal, returns that number and sets <i>ok</i> to true. Otherwise returns 0.0 and sets <i>ok</i> to false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```double QQmlScriptString::numberLiteral(bool* ok) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#numberLiteral">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>If the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is a number literal, returns that number and sets <i>ok</i> to true. Otherwise returns 0.0 and sets <i>ok</i> to false.</p></div>
    #[inline(always)]
    pub unsafe fn number_literal(&self, ok: *mut bool) -> ::std::os::raw::c_double {
        crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_numberLiteral(
            self as *const crate::QQmlScriptString,
            ok,
        )
    }

    /// <p>If the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is a string literal, returns that string. Otherwise returns a null <a href="http://doc.qt.io/qt-5/qstring.html">QString</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlScriptString::stringLiteral() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#stringLiteral">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>If the content of the <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> is a string literal, returns that string. Otherwise returns a null <a href="http://doc.qt.io/qt-5/qstring.html">QString</a>.</p></div>
    #[inline(always)]
    pub unsafe fn string_literal(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_stringLiteral(
                self as *const crate::QQmlScriptString,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p>For example, given a file <code>main.qml</code> like this:</p>
///
/// C++ class: <span style='color: green;'>```QQmlExpression```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlexpression.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>For example, given a file <code>main.qml</code> like this:</p>
/// <pre class="qml">
///
///   import QtQuick 2.0
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qml-qtquick-item.html">Item</a></span> {
/// &#32;     <span class="name">width</span>: <span class="number">200</span>; <span class="name">height</span>: <span class="number">200</span>
///   }
///
/// </pre>
/// <p>The following code evaluates a JavaScript expression in the context of the above QML:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> <span class="operator">*</span>engine <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span>;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a></span> component(engine<span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"main.qml"</span>));
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html#QObject">QObject</a></span> <span class="operator">*</span>myObject <span class="operator">=</span> component<span class="operator">.</span>create();
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression">QQmlExpression</a></span> <span class="operator">*</span>expr <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression">QQmlExpression</a></span>(engine<span class="operator">-</span><span class="operator">&gt;</span>rootContext()<span class="operator">,</span> myObject<span class="operator">,</span> <span class="string">"width * 2"</span>);
///   <span class="type">int</span> result <span class="operator">=</span> expr<span class="operator">-</span><span class="operator">&gt;</span>evaluate()<span class="operator">.</span>toInt();  <span class="comment">// result = 400</span>
///
/// </pre></div>
#[repr(C)]
pub struct QQmlExpression {
    _unused: u8,
}
impl QQmlExpression {
    /// <p>Emitted each time the expression value changes from the last time it was evaluated. The expression must have been evaluated at least once (by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">QQmlExpression::evaluate</a>()) before this signal will be emitted.</p>
    ///
    /// Returns a built-in Qt signal `QQmlExpression::valueChanged` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#valueChanged">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Emitted each time the expression value changes from the last time it was evaluated. The expression must have been evaluated at least once (by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">QQmlExpression::evaluate</a>()) before this signal will be emitted.</p></div>
    #[inline(always)]
    pub fn value_changed(&self) -> ::qt_core::Signal<()> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"2valueChanged()\0"),
            )
        }
    }

    /// <p>Clear any expression errors. Calls to <a href="http://doc.qt.io/qt-5/qqmlexpression.html#hasError">hasError</a>() following this will return false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlExpression::clearError()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#clearError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Clear any expression errors. Calls to <a href="http://doc.qt.io/qt-5/qqmlexpression.html#hasError">hasError</a>() following this will return false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#hasError">hasError</a>() and <a href="http://doc.qt.io/qt-5/qqmlexpression.html#error">error</a>().</p></div>
    #[inline(always)]
    pub unsafe fn clear_error(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_clearError(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
        )
    }

    /// <p>Returns the source file column number for this expression. The source location must have been previously set by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">setSourceLocation</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlExpression::columnNumber() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#columnNumber">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the source file column number for this expression. The source location must have been previously set by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">setSourceLocation</a>().</p></div>
    #[inline(always)]
    pub unsafe fn column_number(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_columnNumber(
            self as *const crate::QQmlExpression,
        )
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> this expression is associated with, or 0 if there is no association or the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> has been destroyed.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext* QQmlExpression::context() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#context">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> this expression is associated with, or 0 if there is no association or the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> has been destroyed.</p></div>
    #[inline(always)]
    pub unsafe fn context(&self) -> ::qt_core::QPtr<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_context(
                self as *const crate::QQmlExpression,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> this expression is associated with, or 0 if there is no association or the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> has been destroyed.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* QQmlExpression::engine() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#engine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> this expression is associated with, or 0 if there is no association or the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> has been destroyed.</p></div>
    #[inline(always)]
    pub unsafe fn engine(&self) -> ::qt_core::QPtr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_engine(self as *const crate::QQmlExpression)
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Return any error from the last call to <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">evaluate</a>(). If there was no error, this returns an invalid <a href="http://doc.qt.io/qt-5/qqmlerror.html">QQmlError</a> instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError QQmlExpression::error() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#error">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return any error from the last call to <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">evaluate</a>(). If there was no error, this returns an invalid <a href="http://doc.qt.io/qt-5/qqmlerror.html">QQmlError</a> instance.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#hasError">hasError</a>() and <a href="http://doc.qt.io/qt-5/qqmlexpression.html#clearError">clearError</a>().</p></div>
    #[inline(always)]
    pub unsafe fn error(&self) -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_error(self as *const crate::QQmlExpression)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Evaulates the expression, returning the result of the evaluation, or an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> if the expression is invalid or has an error.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant QQmlExpression::evaluate(bool* valueIsUndefined = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Evaulates the expression, returning the result of the evaluation, or an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> if the expression is invalid or has an error.</p>
    /// <p><i>valueIsUndefined</i> is set to true if the expression resulted in an undefined value.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#hasError">hasError</a>() and <a href="http://doc.qt.io/qt-5/qqmlexpression.html#error">error</a>().</p></div>
    #[inline(always)]
    pub unsafe fn evaluate_1a(
        &self,
        value_is_undefined: *mut bool,
    ) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_evaluate(
                self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
                value_is_undefined,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Evaulates the expression, returning the result of the evaluation, or an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> if the expression is invalid or has an error.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant QQmlExpression::evaluate()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Evaulates the expression, returning the result of the evaluation, or an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> if the expression is invalid or has an error.</p>
    /// <p><i>valueIsUndefined</i> is set to true if the expression resulted in an undefined value.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#hasError">hasError</a>() and <a href="http://doc.qt.io/qt-5/qqmlexpression.html#error">error</a>().</p></div>
    #[inline(always)]
    pub unsafe fn evaluate_0a(&self) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_evaluate1(
                self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the expression string.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlExpression::expression() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#expression">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the expression string.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#setExpression">setExpression</a>().</p></div>
    #[inline(always)]
    pub unsafe fn expression(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_expression(
                self as *const crate::QQmlExpression,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns true if the last call to <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">evaluate</a>() resulted in an error, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlExpression::hasError() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#hasError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the last call to <a href="http://doc.qt.io/qt-5/qqmlexpression.html#evaluate">evaluate</a>() resulted in an error, otherwise false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#error">error</a>() and <a href="http://doc.qt.io/qt-5/qqmlexpression.html#clearError">clearError</a>().</p></div>
    #[inline(always)]
    pub unsafe fn has_error(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_hasError(self as *const crate::QQmlExpression)
    }

    /// <p>Returns the source file line number for this expression. The source location must have been previously set by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">setSourceLocation</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlExpression::lineNumber() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#lineNumber">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the source file line number for this expression. The source location must have been previously set by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">setSourceLocation</a>().</p></div>
    #[inline(always)]
    pub unsafe fn line_number(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_lineNumber(self as *const crate::QQmlExpression)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlExpression::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_metaObject(
                self as *const crate::QQmlExpression,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Create an invalid <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlExpression::QQmlExpression()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an invalid <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a>.</p>
    /// <p>As the expression will not have an associated <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>, this will be a null expression object and its value will always be an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::qt_core::QBox<crate::QQmlExpression> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_QQmlExpression() };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlExpression::QQmlExpression(QQmlContext* arg1, QObject* arg2, const QString& arg3, QObject* arg4 = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    /// <p>The <i>expression</i> JavaScript will be executed in the <i>ctxt</i> <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>. If specified, the <i>scope</i> object's properties will also be in scope during the expression's execution.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_context_q_object_q_string_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg4: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_QQmlExpression1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg2)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg3)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg4)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlExpression::QQmlExpression(const QQmlScriptString& arg1, QQmlContext* arg2 = …, QObject* arg3 = …, QObject* arg4 = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    /// <p>The <i>script</i> provides the expression to be evaluated, the context to evaluate it in, and the scope object to evaluate it with. If provided, <i>ctxt</i> and <i>scope</i> will override the context and scope object provided by <i>script</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_script_string_q_qml_context2_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlScriptString>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg4: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_QQmlExpression2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlScriptString>>::cast_into(arg1)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg2)
                    .as_raw_ptr() as *mut crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg3)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg4)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlExpression::QQmlExpression(QQmlContext* arg1, QObject* arg2, const QString& arg3)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    /// <p>The <i>expression</i> JavaScript will be executed in the <i>ctxt</i> <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>. If specified, the <i>scope</i> object's properties will also be in scope during the expression's execution.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_context_q_object_q_string(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::qt_core::QBox<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_QQmlExpression3(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg2)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg3)
                    .as_raw_ptr(),
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlExpression::QQmlExpression(const QQmlScriptString& arg1, QQmlContext* arg2 = …, QObject* arg3 = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    /// <p>The <i>script</i> provides the expression to be evaluated, the context to evaluate it in, and the scope object to evaluate it with. If provided, <i>ctxt</i> and <i>scope</i> will override the context and scope object provided by <i>script</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_script_string_q_qml_context_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlScriptString>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_QQmlExpression4(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlScriptString>>::cast_into(arg1)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg2)
                    .as_raw_ptr() as *mut crate::QQmlContext,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg3)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlExpression::QQmlExpression(const QQmlScriptString& arg1, QQmlContext* arg2 = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    /// <p>The <i>script</i> provides the expression to be evaluated, the context to evaluate it in, and the scope object to evaluate it with. If provided, <i>ctxt</i> and <i>scope</i> will override the context and scope object provided by <i>script</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_script_string_q_qml_context(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlScriptString>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::qt_core::QBox<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_QQmlExpression5(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlScriptString>>::cast_into(arg1)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg2)
                    .as_raw_ptr() as *mut crate::QQmlContext,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlExpression::QQmlExpression(const QQmlScriptString& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#QQmlExpression-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> object that is a child of <i>parent</i>.</p>
    /// <p>The <i>script</i> provides the expression to be evaluated, the context to evaluate it in, and the scope object to evaluate it with. If provided, <i>ctxt</i> and <i>scope</i> will override the context and scope object provided by <i>script</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_qml_script_string(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlScriptString>>,
    ) -> ::qt_core::QBox<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_QQmlExpression6(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlScriptString>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Returns true if the <a href="http://doc.qt.io/qt-5/qqmlexpression.html#valueChanged">valueChanged</a>() signal is emitted when the expression's evaluated value changes.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlExpression::notifyOnValueChanged() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#notifyOnValueChanged">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the <a href="http://doc.qt.io/qt-5/qqmlexpression.html#valueChanged">valueChanged</a>() signal is emitted when the expression's evaluated value changes.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#setNotifyOnValueChanged">setNotifyOnValueChanged</a>().</p></div>
    #[inline(always)]
    pub unsafe fn notify_on_value_changed(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_notifyOnValueChanged(
            self as *const crate::QQmlExpression,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlExpression::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_qt_metacall(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlExpression::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_qt_metacast(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
            arg1,
        )
    }

    /// <p>Returns the expression's scope object, if provided, otherwise 0.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlExpression::scopeObject() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#scopeObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the expression's scope object, if provided, otherwise 0.</p>
    /// <p>In addition to data provided by the expression's <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>, the scope object's properties are also in scope during the expression's evaluation.</p></div>
    #[inline(always)]
    pub unsafe fn scope_object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_scopeObject(
                self as *const crate::QQmlExpression,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Set the expression to <i>expression</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlExpression::setExpression(const QString& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setExpression">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set the expression to <i>expression</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#expression">expression</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_expression(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_setExpression(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg1)
                .as_raw_ptr(),
        )
    }

    /// <p>Sets whether the <a href="http://doc.qt.io/qt-5/qqmlexpression.html#valueChanged">valueChanged</a>() signal is emitted when the expression's evaluated value changes.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlExpression::setNotifyOnValueChanged(bool arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setNotifyOnValueChanged">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets whether the <a href="http://doc.qt.io/qt-5/qqmlexpression.html#valueChanged">valueChanged</a>() signal is emitted when the expression's evaluated value changes.</p>
    /// <p>If <i>notifyOnChange</i> is true, the <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> will monitor properties involved in the expression's evaluation, and emit <a href="http://doc.qt.io/qt-5/qqmlexpression.html#valueChanged">QQmlExpression::valueChanged</a>() if they have changed. This allows an application to ensure that any value associated with the result of the expression remains up to date.</p>
    /// <p>If <i>notifyOnChange</i> is false (default), the <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> will not montitor properties involved in the expression's evaluation, and <a href="http://doc.qt.io/qt-5/qqmlexpression.html#valueChanged">QQmlExpression::valueChanged</a>() will never be emitted. This is more efficient if an application wants a "one off" evaluation of the expression.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlexpression.html#notifyOnValueChanged">notifyOnValueChanged</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_notify_on_value_changed(&self, arg1: bool) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_setNotifyOnValueChanged(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
            arg1,
        )
    }

    /// <p>Set the location of this expression to <i>line</i> and <i>column</i> of <i>url</i>. This information is used by the script engine.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlExpression::setSourceLocation(const QString& fileName, int line, int column = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set the location of this expression to <i>line</i> and <i>column</i> of <i>url</i>. This information is used by the script engine.</p></div>
    #[inline(always)]
    pub unsafe fn set_source_location_3a(
        &self,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        line: ::std::os::raw::c_int,
        column: ::std::os::raw::c_int,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_setSourceLocation(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                .as_raw_ptr(),
            line,
            column,
        )
    }

    /// <p>Set the location of this expression to <i>line</i> and <i>column</i> of <i>url</i>. This information is used by the script engine.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlExpression::setSourceLocation(const QString& fileName, int line)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Set the location of this expression to <i>line</i> and <i>column</i> of <i>url</i>. This information is used by the script engine.</p></div>
    #[inline(always)]
    pub unsafe fn set_source_location_2a(
        &self,
        file_name: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        line: ::std::os::raw::c_int,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_setSourceLocation1(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(file_name)
                .as_raw_ptr(),
            line,
        )
    }

    /// <p>Returns the source file URL for this expression. The source location must have been previously set by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">setSourceLocation</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlExpression::sourceFile() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#sourceFile">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the source file URL for this expression. The source location must have been previously set by calling <a href="http://doc.qt.io/qt-5/qqmlexpression.html#setSourceLocation">setSourceLocation</a>().</p></div>
    #[inline(always)]
    pub unsafe fn source_file(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_sourceFile(
                self as *const crate::QQmlExpression,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlExpression::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlExpression::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```QQmlTypesExtensionInterface```</span>.
#[repr(C)]
pub struct QQmlTypesExtensionInterface {
    _unused: u8,
}
impl QQmlTypesExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```QQmlTypesExtensionInterface& QQmlTypesExtensionInterface::operator=(const QQmlTypesExtensionInterface& other)```</span>.
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlTypesExtensionInterface>>,
    ) -> ::cpp_core::Ref<crate::QQmlTypesExtensionInterface> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlTypesExtensionInterface_operator_(self as *const crate::QQmlTypesExtensionInterface as *mut crate::QQmlTypesExtensionInterface, ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlTypesExtensionInterface>>::cast_into(other).as_raw_ptr())
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```pure virtual void QQmlTypesExtensionInterface::registerTypes(const char* uri)```</span>.
    #[inline(always)]
    pub unsafe fn register_types(&self, uri: *const ::std::os::raw::c_char) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlTypesExtensionInterface_registerTypes(
            self as *const crate::QQmlTypesExtensionInterface
                as *mut crate::QQmlTypesExtensionInterface,
            uri,
        )
    }
}

/// C++ class: <span style='color: green;'>```QQmlExtensionInterface```</span>.
#[repr(C)]
pub struct QQmlExtensionInterface {
    _unused: u8,
}
impl QQmlExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionInterface& QQmlExtensionInterface::operator=(const QQmlExtensionInterface& other)```</span>.
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlExtensionInterface>>,
    ) -> ::cpp_core::Ref<crate::QQmlExtensionInterface> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionInterface_operator_(
                self as *const crate::QQmlExtensionInterface as *mut crate::QQmlExtensionInterface,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlExtensionInterface>>::cast_into(
                    other,
                )
                .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```pure virtual void QQmlExtensionInterface::initializeEngine(QQmlEngine* engine, const char* uri)```</span>.
    #[inline(always)]
    pub unsafe fn initialize_engine(
        &self,
        engine: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        uri: *const ::std::os::raw::c_char,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionInterface_initializeEngine(
            self as *const crate::QQmlExtensionInterface as *mut crate::QQmlExtensionInterface,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(engine)
                .as_raw_ptr() as *mut crate::QQmlEngine,
            uri,
        )
    }
}

/// <p><a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html">QQmlExtensionPlugin</a> is a plugin interface that makes it possible to create QML extensions that can be loaded dynamically into QML applications. These extensions allow custom QML types to be made available to the QML engine.</p>
///
/// C++ class: <span style='color: green;'>```QQmlExtensionPlugin```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html">QQmlExtensionPlugin</a> is a plugin interface that makes it possible to create QML extensions that can be loaded dynamically into QML applications. These extensions allow custom QML types to be made available to the QML engine.</p>
/// <p>To write a QML extension plugin:</p>
/// <ol class="1" type="1"><li>Subclass <a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html">QQmlExtensionPlugin</a><ul>
/// <li>Use the <a href="http://doc.qt.io/qt-5/#Q_PLUGIN_METADATA">Q_PLUGIN_METADATA</a>() macro to register the plugin with the Qt meta object system</li>
/// <li>Override the <a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html#registerTypes">registerTypes()</a> method and call <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType-1">qmlRegisterType</a>() to register the types to be exported by the plugin</li>
/// </ul>
/// </li>
/// <li>Write a project file for the plugin</li>
/// <li>Create a <a href="http://doc.qt.io/qt-5/qtqml-modules-qmldir.html#">qmldir file</a> to describe the plugin</li>
/// </ol>
/// <p>QML extension plugins are for either application-specific or library-like plugins. Library plugins should limit themselves to registering types, as any manipulation of the engine's root context may cause conflicts or other issues in the library user's code.</p>
/// <a name="timeexample-qml-extension-plugin"></a></div>
#[repr(C)]
pub struct QQmlExtensionPlugin {
    _unused: u8,
}
impl QQmlExtensionPlugin {
    /// <p>Returns the URL of the directory from which the extension is loaded.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QUrl QQmlExtensionPlugin::baseUrl() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html#baseUrl">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the URL of the directory from which the extension is loaded.</p>
    /// <p>This is useful when the plugin also needs to load QML files or other assets from the same directory.</p>
    /// <p>This function was introduced in  Qt 5.1.</p></div>
    #[inline(always)]
    pub unsafe fn base_url(&self) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_baseUrl(
                self as *const crate::QQmlExtensionPlugin,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Initializes the extension from the <i>uri</i> using the <i>engine</i>. Here an application plugin might, for example, expose some data or objects to QML, as context properties on the engine's root context.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual void QQmlExtensionPlugin::initializeEngine(QQmlEngine* engine, const char* uri)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html#initializeEngine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Initializes the extension from the <i>uri</i> using the <i>engine</i>. Here an application plugin might, for example, expose some data or objects to QML, as context properties on the engine's root context.</p></div>
    #[inline(always)]
    pub unsafe fn initialize_engine(
        &self,
        engine: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        uri: *const ::std::os::raw::c_char,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_initializeEngine(
            self as *const crate::QQmlExtensionPlugin as *mut crate::QQmlExtensionPlugin,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(engine)
                .as_raw_ptr() as *mut crate::QQmlEngine,
            uri,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlExtensionPlugin::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_metaObject(
                self as *const crate::QQmlExtensionPlugin,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlExtensionPlugin::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_qt_metacall(
            self as *const crate::QQmlExtensionPlugin as *mut crate::QQmlExtensionPlugin,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlExtensionPlugin::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_qt_metacast(
            self as *const crate::QQmlExtensionPlugin as *mut crate::QQmlExtensionPlugin,
            arg1,
        )
    }

    /// <p>Registers the QML types in the given <i>uri</i>. Subclasses should implement this to call <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType-1">qmlRegisterType</a>() for all types which are provided by the extension plugin.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```pure virtual void QQmlExtensionPlugin::registerTypes(const char* uri)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlextensionplugin.html#registerTypes">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Registers the QML types in the given <i>uri</i>. Subclasses should implement this to call <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType-1">qmlRegisterType</a>() for all types which are provided by the extension plugin.</p>
    /// <p>The <i>uri</i> is an identifier for the plugin generated by the QML engine based on the name and path of the extension's plugin library.</p></div>
    #[inline(always)]
    pub unsafe fn register_types(&self, uri: *const ::std::os::raw::c_char) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_registerTypes(
            self as *const crate::QQmlExtensionPlugin as *mut crate::QQmlExtensionPlugin,
            uri,
        )
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlExtensionPlugin::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlExtensionPlugin::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_qml_file {
    //! C++ type: <span style='color: green;'>```QQmlFile```</span>

    /// C++ enum: <span style='color: green;'>```QQmlFile::Status```</span>.
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Status(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for Status {
        fn from(value: ::std::os::raw::c_int) -> Self {
            Status(value)
        }
    }

    impl From<Status> for ::std::os::raw::c_int {
        fn from(value: Status) -> Self {
            value.0
        }
    }

    impl Status {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl Status {
        /// C++ enum variant: <span style='color: green;'>```Null = 0```</span>
        #[allow(non_upper_case_globals)]
        pub const Null: crate::q_qml_file::Status = crate::q_qml_file::Status(0);
        /// C++ enum variant: <span style='color: green;'>```Ready = 1```</span>
        #[allow(non_upper_case_globals)]
        pub const Ready: crate::q_qml_file::Status = crate::q_qml_file::Status(1);
        /// C++ enum variant: <span style='color: green;'>```Error = 2```</span>
        #[allow(non_upper_case_globals)]
        pub const Error: crate::q_qml_file::Status = crate::q_qml_file::Status(2);
        /// C++ enum variant: <span style='color: green;'>```Loading = 3```</span>
        #[allow(non_upper_case_globals)]
        pub const Loading: crate::q_qml_file::Status = crate::q_qml_file::Status(3);
    }
}
/// C++ class: <span style='color: green;'>```QQmlFile```</span>.
#[repr(C)]
pub struct QQmlFile {
    _unused: u8,
}
impl QQmlFile {
    /// Calls C++ function: <span style='color: green;'>```void QQmlFile::clear()```</span>.
    #[inline(always)]
    pub unsafe fn clear_0a(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_clear(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QQmlFile::clear(QObject* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn clear_1a(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_clear1(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::connectDownloadProgress(QObject* arg1, const char* arg2)```</span>.
    #[inline(always)]
    pub unsafe fn connect_download_progress_q_object_char(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: *const ::std::os::raw::c_char,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_connectDownloadProgress(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            arg2,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::connectDownloadProgress(QObject* arg1, int arg2)```</span>.
    #[inline(always)]
    pub unsafe fn connect_download_progress_q_object_int(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: ::std::os::raw::c_int,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_connectDownloadProgress1(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            arg2,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::connectFinished(QObject* arg1, const char* arg2)```</span>.
    #[inline(always)]
    pub unsafe fn connect_finished_q_object_char(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: *const ::std::os::raw::c_char,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_connectFinished(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            arg2,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::connectFinished(QObject* arg1, int arg2)```</span>.
    #[inline(always)]
    pub unsafe fn connect_finished_q_object_int(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: ::std::os::raw::c_int,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_connectFinished1(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            arg2,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```const char* QQmlFile::data() const```</span>.
    #[inline(always)]
    pub unsafe fn data(&self) -> *const ::std::os::raw::c_char {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_data(self as *const crate::QQmlFile)
    }

    /// Calls C++ function: <span style='color: green;'>```QByteArray QQmlFile::dataByteArray() const```</span>.
    #[inline(always)]
    pub unsafe fn data_byte_array(&self) -> ::cpp_core::CppBox<::qt_core::QByteArray> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlFile_dataByteArray(self as *const crate::QQmlFile) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```QString QQmlFile::error() const```</span>.
    #[inline(always)]
    pub unsafe fn error(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlFile_error(self as *const crate::QQmlFile) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::isError() const```</span>.
    #[inline(always)]
    pub unsafe fn is_error(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isError(self as *const crate::QQmlFile)
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::isLoading() const```</span>.
    #[inline(always)]
    pub unsafe fn is_loading(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isLoading(self as *const crate::QQmlFile)
    }

    /// Calls C++ function: <span style='color: green;'>```static bool QQmlFile::isLocalFile(const QString& url)```</span>.
    #[inline(always)]
    pub unsafe fn is_local_file_q_string(
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isLocalFile(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(url)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```static bool QQmlFile::isLocalFile(const QUrl& url)```</span>.
    #[inline(always)]
    pub unsafe fn is_local_file_q_url(
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isLocalFile1(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::isNull() const```</span>.
    #[inline(always)]
    pub unsafe fn is_null(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isNull(self as *const crate::QQmlFile)
    }

    /// Calls C++ function: <span style='color: green;'>```bool QQmlFile::isReady() const```</span>.
    #[inline(always)]
    pub unsafe fn is_ready(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isReady(self as *const crate::QQmlFile)
    }

    /// Calls C++ function: <span style='color: green;'>```static bool QQmlFile::isSynchronous(const QString& url)```</span>.
    #[inline(always)]
    pub unsafe fn is_synchronous_q_string(
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isSynchronous(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(url)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```static bool QQmlFile::isSynchronous(const QUrl& url)```</span>.
    #[inline(always)]
    pub unsafe fn is_synchronous_q_url(
        url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_isSynchronous1(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QQmlFile::load(QQmlEngine* arg1, const QUrl& arg2)```</span>.
    #[inline(always)]
    pub unsafe fn load_q_qml_engine_q_url(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_load(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1).as_raw_ptr()
                as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg2).as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QQmlFile::load(QQmlEngine* arg1, const QString& arg2)```</span>.
    #[inline(always)]
    pub unsafe fn load_q_qml_engine_q_string(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_load1(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1).as_raw_ptr()
                as *mut crate::QQmlEngine,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlFile::QQmlFile()```</span>.
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QQmlFile> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlFile_QQmlFile() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlFile::QQmlFile(QQmlEngine* arg1, const QUrl& arg2)```</span>.
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_url(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) -> ::cpp_core::CppBox<crate::QQmlFile> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFile_QQmlFile1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg2)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlFile::QQmlFile(QQmlEngine* arg1, const QString& arg2)```</span>.
    #[inline(always)]
    pub unsafe fn from_q_qml_engine_q_string(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QQmlFile> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFile_QQmlFile2(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```qint64 QQmlFile::size() const```</span>.
    #[inline(always)]
    pub unsafe fn size(&self) -> i64 {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_size(self as *const crate::QQmlFile)
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlFile::Status QQmlFile::status() const```</span>.
    #[inline(always)]
    pub unsafe fn status(&self) -> crate::q_qml_file::Status {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_status(self as *const crate::QQmlFile)
    }

    /// Calls C++ function: <span style='color: green;'>```QUrl QQmlFile::url() const```</span>.
    #[inline(always)]
    pub unsafe fn url(&self) -> ::cpp_core::CppBox<::qt_core::QUrl> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlFile_url(self as *const crate::QQmlFile) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlFile::urlToLocalFileOrQrc(const QString& arg1)```</span>.
    #[inline(always)]
    pub unsafe fn url_to_local_file_or_qrc_q_string(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFile_urlToLocalFileOrQrc(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlFile::urlToLocalFileOrQrc(const QUrl& arg1)```</span>.
    #[inline(always)]
    pub unsafe fn url_to_local_file_or_qrc_q_url(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFile_urlToLocalFileOrQrc1(
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p><a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> will automatically apply a <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> to qml file and asset paths.</p>
///
/// C++ class: <span style='color: green;'>```QQmlFileSelector```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> will automatically apply a <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> to qml file and asset paths.</p>
/// <p>It is used as follows:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a></span> engine;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlfileselector.html#QQmlFileSelector">QQmlFileSelector</a></span><span class="operator">*</span> selector <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qqmlfileselector.html#QQmlFileSelector">QQmlFileSelector</a></span>(<span class="operator">&amp;</span>engine);
///
/// </pre>
/// <p>Then you can swap out files like so:</p>
/// <pre class="cpp">
///
///   main<span class="operator">.</span>qml
///   Component<span class="operator">.</span>qml
///   asset<span class="operator">.</span>png
///   <span class="operator">+</span>unix<span class="operator">/</span>Component<span class="operator">.</span>qml
///   <span class="operator">+</span>mac<span class="operator">/</span>asset<span class="operator">.</span>png
///
/// </pre>
/// <p>In this example, main.qml will normally use Component.qml for the Component type. However on a unix platform, the unix selector will be present and the +unix/Component.qml version will be used instead. Note that this acts like swapping out Component.qml with +unix/Component.qml, so when using Component.qml you should not need to alter any paths based on which version was selected.</p>
/// <p>For example, to pass the "asset.png" file path around you would refer to it just as "asset.png" in all of main.qml, Component.qml, and +linux/Component.qml. It will be replaced with +mac/asset.png on Mac platforms in all cases.</p>
/// <p>For a list of available selectors, see <code>QFileSelector</code>.</p>
/// <p>Your platform may also provide additional selectors for you to use. As specified by <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a>, directories used for selection must start with a '+' character, so you will not accidentally trigger this feature unless you have directories with such names inside your project.</p>
/// <p>If a new <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> is set on the engine, the old one will be replaced. Use <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#get">QQmlFileSelector::get</a>() to query or use the existing instance.</p></div>
#[repr(C)]
pub struct QQmlFileSelector {
    _unused: u8,
}
impl QQmlFileSelector {
    /// <p>Gets the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> currently active on the target <i>engine</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QQmlFileSelector* QQmlFileSelector::get(QQmlEngine* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#get">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Gets the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> currently active on the target <i>engine</i>.</p></div>
    #[inline(always)]
    pub unsafe fn get(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::qt_core::QPtr<crate::QQmlFileSelector> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_get(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg1)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlFileSelector::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_metaObject(
                self as *const crate::QQmlFileSelector,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Creates a new <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> with parent object <i>parent</i>, which includes its own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a>. <i>engine</i> is the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> you wish to apply file selectors to. It will also take ownership of the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlFileSelector::QQmlFileSelector(QQmlEngine* engine, QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#QQmlFileSelector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a new <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> with parent object <i>parent</i>, which includes its own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a>. <i>engine</i> is the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> you wish to apply file selectors to. It will also take ownership of the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new_2a(
        engine: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlFileSelector> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_QQmlFileSelector(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(engine)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p>Creates a new <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> with parent object <i>parent</i>, which includes its own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a>. <i>engine</i> is the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> you wish to apply file selectors to. It will also take ownership of the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlFileSelector::QQmlFileSelector(QQmlEngine* engine)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#QQmlFileSelector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a new <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> with parent object <i>parent</i>, which includes its own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a>. <i>engine</i> is the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> you wish to apply file selectors to. It will also take ownership of the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new_1a(
        engine: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::qt_core::QBox<crate::QQmlFileSelector> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_QQmlFileSelector2(
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(engine)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlFileSelector::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_qt_metacall(
            self as *const crate::QQmlFileSelector as *mut crate::QQmlFileSelector,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlFileSelector::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_qt_metacast(
            self as *const crate::QQmlFileSelector as *mut crate::QQmlFileSelector,
            arg1,
        )
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance used by the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QFileSelector* QQmlFileSelector::selector() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#selector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance used by the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a>.</p>
    /// <p>This function was introduced in  Qt 5.7.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlfileselector.html#setSelector">setSelector</a>().</p></div>
    #[inline(always)]
    pub unsafe fn selector(&self) -> ::qt_core::QPtr<::qt_core::QFileSelector> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_selector(
                self as *const crate::QQmlFileSelector,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Adds extra selectors contained in <i>strings</i> to the current <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> being used. Use this when extra selectors are all you need to avoid having to create your own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlFileSelector::setExtraSelectors(QStringList& strings)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#setExtraSelectors">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Adds extra selectors contained in <i>strings</i> to the current <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> being used. Use this when extra selectors are all you need to avoid having to create your own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance.</p></div>
    #[inline(always)]
    pub unsafe fn set_extra_selectors_q_string_list(
        &self,
        strings: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QStringList>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_setExtraSelectors(
            self as *const crate::QQmlFileSelector as *mut crate::QQmlFileSelector,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QStringList>>::cast_into(strings)
                .as_raw_ptr() as *mut ::qt_core::QStringList,
        )
    }

    /// <p>Adds extra selectors contained in <i>strings</i> to the current <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> being used. Use this when extra selectors are all you need to avoid having to create your own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlFileSelector::setExtraSelectors(const QStringList& strings)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#setExtraSelectors-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Adds extra selectors contained in <i>strings</i> to the current <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> being used. Use this when extra selectors are all you need to avoid having to create your own <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance.</p></div>
    #[inline(always)]
    pub unsafe fn set_extra_selectors_q_string_list2(
        &self,
        strings: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QStringList>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_setExtraSelectors1(
            self as *const crate::QQmlFileSelector as *mut crate::QQmlFileSelector,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QStringList>>::cast_into(strings)
                .as_raw_ptr(),
        )
    }

    /// <p>Sets the <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance for use by the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> to <i>selector</i>. <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> does not take ownership of the new <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a>. To reset <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> to use its internal <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance, call setSelector(0).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlFileSelector::setSelector(QFileSelector* selector)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#setSelector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance for use by the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> to <i>selector</i>. <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> does not take ownership of the new <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a>. To reset <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> to use its internal <a href="http://doc.qt.io/qt-5/qfileselector.html">QFileSelector</a> instance, call setSelector(0).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlfileselector.html#selector">selector</a>().</p></div>
    #[inline(always)]
    pub unsafe fn set_selector(
        &self,
        selector: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QFileSelector>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_setSelector(
            self as *const crate::QQmlFileSelector as *mut crate::QQmlFileSelector,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QFileSelector>>::cast_into(selector)
                .as_raw_ptr() as *mut ::qt_core::QFileSelector,
        )
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlFileSelector::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlFileSelector::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_qml_incubator {
    //! C++ type: <span style='color: green;'>```QQmlIncubator```</span>

    /// <p>Specifies the mode the incubator operates in. Regardless of the incubation mode, a <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> will behave synchronously if the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> does not have a <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">QQmlIncubationController</a> set.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlIncubator::IncubationMode```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Specifies the mode the incubator operates in. Regardless of the incubation mode, a <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> will behave synchronously if the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> does not have a <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">QQmlIncubationController</a> set.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct IncubationMode(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for IncubationMode {
        fn from(value: ::std::os::raw::c_int) -> Self {
            IncubationMode(value)
        }
    }

    impl From<IncubationMode> for ::std::os::raw::c_int {
        fn from(value: IncubationMode) -> Self {
            value.0
        }
    }

    impl IncubationMode {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl IncubationMode {
        /// The object will be created asynchronously. (C++ enum variant: <span style='color: green;'>```Asynchronous = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const Asynchronous: crate::q_qml_incubator::IncubationMode =
            crate::q_qml_incubator::IncubationMode(0);
        /// If the object is being created in a context that is already part of an asynchronous creation, this incubator will join that existing incubation and execute asynchronously. The existing incubation will not become Ready until both it and this incubation have completed. Otherwise, the incubation will execute synchronously. (C++ enum variant: <span style='color: green;'>```AsynchronousIfNested = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const AsynchronousIfNested: crate::q_qml_incubator::IncubationMode =
            crate::q_qml_incubator::IncubationMode(1);
        /// The object will be created synchronously. (C++ enum variant: <span style='color: green;'>```Synchronous = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const Synchronous: crate::q_qml_incubator::IncubationMode =
            crate::q_qml_incubator::IncubationMode(2);
    }

    /// <p>Specifies the status of the <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a>.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlIncubator::Status```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#Status-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Specifies the status of the <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a>.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Status(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for Status {
        fn from(value: ::std::os::raw::c_int) -> Self {
            Status(value)
        }
    }

    impl From<Status> for ::std::os::raw::c_int {
        fn from(value: Status) -> Self {
            value.0
        }
    }

    impl Status {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl Status {
        /// Incubation is not in progress. Call <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() to begin incubating. (C++ enum variant: <span style='color: green;'>```Null = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const Null: crate::q_qml_incubator::Status = crate::q_qml_incubator::Status(0);
        /// The object is fully created and can be accessed by calling <a href="http://doc.qt.io/qt-5/qqmlincubator.html#object">object</a>(). (C++ enum variant: <span style='color: green;'>```Ready = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const Ready: crate::q_qml_incubator::Status = crate::q_qml_incubator::Status(1);
        /// The object is in the process of being created. (C++ enum variant: <span style='color: green;'>```Loading = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const Loading: crate::q_qml_incubator::Status = crate::q_qml_incubator::Status(2);
        /// An error occurred. The errors can be access by calling <a href="http://doc.qt.io/qt-5/qqmlincubator.html#errors">errors</a>(). (C++ enum variant: <span style='color: green;'>```Error = 3```</span>)
        #[allow(non_upper_case_globals)]
        pub const Error: crate::q_qml_incubator::Status = crate::q_qml_incubator::Status(3);
    }
}
/// <p>Creating QML objects - like delegates in a view, or a new page in an application - can take a noticeable amount of time, especially on resource constrained mobile devices. When an application uses <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() directly, the QML object instance is created synchronously which, depending on the complexity of the object, can cause noticeable pauses or stutters in the application.</p>
///
/// C++ class: <span style='color: green;'>```QQmlIncubator```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlincubator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creating QML objects - like delegates in a view, or a new page in an application - can take a noticeable amount of time, especially on resource constrained mobile devices. When an application uses <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() directly, the QML object instance is created synchronously which, depending on the complexity of the object, can cause noticeable pauses or stutters in the application.</p>
/// <p>The use of <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> gives more control over the creation of a QML object, including allowing it to be created asynchronously using application idle time. The following example shows a simple use of <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a>.</p>
/// <pre class="cpp">
///
///   <span class="type">QQmlIncubator</span> incubator;
///   component<span class="operator">-</span><span class="operator">&gt;</span>create(incubator);
///
///   <span class="keyword">while</span> (<span class="operator">!</span>incubator<span class="operator">.</span>isReady()) {
/// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qcoreapplication.html">QCoreApplication</a></span><span class="operator">::</span>processEvents(<span class="type"><a href="http://doc.qt.io/qt-5/qeventloop.html">QEventLoop</a></span><span class="operator">::</span>AllEvents<span class="operator">,</span> <span class="number">50</span>);
///   }
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a></span> <span class="operator">*</span>object <span class="operator">=</span> incubator<span class="operator">.</span>object();
///
/// </pre>
/// <p>Asynchronous incubators are controlled by a <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">QQmlIncubationController</a> that is set on the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>, which lets the engine know when the application is idle and incubating objects should be processed. If an incubation controller is not set on the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>, <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> creates objects synchronously regardless of the specified <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">IncubationMode</a>.</p>
/// <p><a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> supports three incubation modes:</p>
/// <ul>
/// <li>Synchronous The creation occurs synchronously. That is, once the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() call returns, the incubator will already be in either the Error or Ready state. A synchronous incubator has no real advantage compared to using the synchronous creation methods on <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> directly, but it may simplify an application's implementation to use the same API for both synchronous and asynchronous creations.</li>
/// <li>Asynchronous (default) The creation occurs asynchronously, assuming a QQmlIncubatorController is set on the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.<p>The incubator will remain in the Loading state until either the creation is complete or an error occurs. The <a href="http://doc.qt.io/qt-5/qqmlincubator.html#statusChanged">statusChanged</a>() callback can be used to be notified of status changes.</p>
/// <p>Applications should use the Asynchronous incubation mode to create objects that are not needed immediately. For example, the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> type uses Asynchronous incubation to create objects that are slightly off screen while the list is being scrolled. If, during asynchronous creation, the object is needed immediately the <a href="http://doc.qt.io/qt-5/qqmlincubator.html#forceCompletion">QQmlIncubator::forceCompletion</a>() method can be called to complete the creation process synchronously.</p>
/// </li>
/// <li><a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a> The creation will occur asynchronously if part of a nested asynchronous creation, or synchronously if not.<p>In most scenarios where a QML component wants the appearance of a synchronous instantiation, it should use this mode.</p>
/// <p>This mode is best explained with an example. When the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> type is first created, it needs to populate itself with an initial set of delegates to show. If the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> was 400 pixels high, and each delegate was 100 pixels high, it would need to create four initial delegate instances. If the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> used the Asynchronous incubation mode, the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> would always be created empty and then, sometime later, the four initial items would appear.</p>
/// <p>Conversely, if the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> was to use the Synchronous incubation mode it would behave correctly but it may introduce stutters into the application. As QML would have to stop and instantiate the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a>'s delegates synchronously, if the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> was part of a QML component that was being instantiated asynchronously this would undo much of the benefit of asynchronous instantiation.</p>
/// <p>The <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a> mode reconciles this problem. By using <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a>, the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> delegates are instantiated asynchronously if the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> itself is already part of an asynchronous instantiation, and synchronously otherwise. In the case of a nested asynchronous instantiation, the outer asynchronous instantiation will not complete until after all the nested instantiations have also completed. This ensures that by the time the outer asynchronous instantitation completes, inner items like <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> have already completed loading their initial delegates.</p>
/// <p>It is almost always incorrect to use the Synchronous incubation mode - elements or components that want the appearance of synchronous instantiation, but without the downsides of introducing freezes or stutters into the application, should use the <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a> incubation mode.</p>
/// </li>
/// </ul></div>
#[repr(C)]
pub struct QQmlIncubator {
    _unused: u8,
}
impl QQmlIncubator {
    /// <p>Clears the incubator. Any in-progress incubation is aborted. If the incubator is in the Ready state, the created object is <b>not</b> deleted.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlIncubator::clear()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#clear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Clears the incubator. Any in-progress incubation is aborted. If the incubator is in the Ready state, the created object is <b>not</b> deleted.</p></div>
    #[inline(always)]
    pub unsafe fn clear(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_clear(
            self as *const crate::QQmlIncubator as *mut crate::QQmlIncubator,
        )
    }

    /// <p>Return the list of errors encountered while incubating the object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError> QQmlIncubator::errors() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#errors">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the list of errors encountered while incubating the object.</p></div>
    #[inline(always)]
    pub unsafe fn errors(&self) -> ::cpp_core::CppBox<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_errors(self as *const crate::QQmlIncubator)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Force any in-progress incubation to finish synchronously. Once this call returns, the incubator will not be in the Loading state.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlIncubator::forceCompletion()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#forceCompletion">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Force any in-progress incubation to finish synchronously. Once this call returns, the incubator will not be in the Loading state.</p></div>
    #[inline(always)]
    pub unsafe fn force_completion(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_forceCompletion(
            self as *const crate::QQmlIncubator as *mut crate::QQmlIncubator,
        )
    }

    /// <p>Return the incubation mode passed to the <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> constructor.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlIncubator::IncubationMode QQmlIncubator::incubationMode() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#incubationMode">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the incubation mode passed to the <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> constructor.</p></div>
    #[inline(always)]
    pub unsafe fn incubation_mode(&self) -> crate::q_qml_incubator::IncubationMode {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_incubationMode(
            self as *const crate::QQmlIncubator,
        )
    }

    /// <p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Error.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlIncubator::isError() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#isError">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Error.</p></div>
    #[inline(always)]
    pub unsafe fn is_error(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_isError(self as *const crate::QQmlIncubator)
    }

    /// <p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Loading.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlIncubator::isLoading() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#isLoading">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Loading.</p></div>
    #[inline(always)]
    pub unsafe fn is_loading(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_isLoading(self as *const crate::QQmlIncubator)
    }

    /// <p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Null.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlIncubator::isNull() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#isNull">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Null.</p></div>
    #[inline(always)]
    pub unsafe fn is_null(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_isNull(self as *const crate::QQmlIncubator)
    }

    /// <p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Ready.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlIncubator::isReady() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#isReady">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the incubator's <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">status</a>() is Ready.</p></div>
    #[inline(always)]
    pub unsafe fn is_ready(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_isReady(self as *const crate::QQmlIncubator)
    }

    /// <p>Create a new incubator with the specified <i>mode</i></p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlIncubator::QQmlIncubator(QQmlIncubator::IncubationMode arg1 = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#QQmlIncubator-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new incubator with the specified <i>mode</i></p></div>
    #[inline(always)]
    pub unsafe fn new_1a(
        arg1: crate::q_qml_incubator::IncubationMode,
    ) -> ::cpp_core::CppBox<crate::QQmlIncubator> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_QQmlIncubator(arg1) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creating QML objects - like delegates in a view, or a new page in an application - can take a noticeable amount of time, especially on resource constrained mobile devices. When an application uses <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() directly, the QML object instance is created synchronously which, depending on the complexity of the object, can cause noticeable pauses or stutters in the application.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlIncubator::QQmlIncubator()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creating QML objects - like delegates in a view, or a new page in an application - can take a noticeable amount of time, especially on resource constrained mobile devices. When an application uses <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() directly, the QML object instance is created synchronously which, depending on the complexity of the object, can cause noticeable pauses or stutters in the application.</p>
    /// <p>The use of <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> gives more control over the creation of a QML object, including allowing it to be created asynchronously using application idle time. The following example shows a simple use of <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a>.</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type">QQmlIncubator</span> incubator;
    ///   component<span class="operator">-</span><span class="operator">&gt;</span>create(incubator);
    ///
    ///   <span class="keyword">while</span> (<span class="operator">!</span>incubator<span class="operator">.</span>isReady()) {
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qcoreapplication.html">QCoreApplication</a></span><span class="operator">::</span>processEvents(<span class="type"><a href="http://doc.qt.io/qt-5/qeventloop.html">QEventLoop</a></span><span class="operator">::</span>AllEvents<span class="operator">,</span> <span class="number">50</span>);
    ///   }
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a></span> <span class="operator">*</span>object <span class="operator">=</span> incubator<span class="operator">.</span>object();
    ///
    /// </pre>
    /// <p>Asynchronous incubators are controlled by a <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">QQmlIncubationController</a> that is set on the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>, which lets the engine know when the application is idle and incubating objects should be processed. If an incubation controller is not set on the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>, <a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> creates objects synchronously regardless of the specified <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">IncubationMode</a>.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qqmlincubator.html">QQmlIncubator</a> supports three incubation modes:</p>
    /// <ul>
    /// <li>Synchronous The creation occurs synchronously. That is, once the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#create">QQmlComponent::create</a>() call returns, the incubator will already be in either the Error or Ready state. A synchronous incubator has no real advantage compared to using the synchronous creation methods on <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a> directly, but it may simplify an application's implementation to use the same API for both synchronous and asynchronous creations.</li>
    /// <li>Asynchronous (default) The creation occurs asynchronously, assuming a QQmlIncubatorController is set on the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.<p>The incubator will remain in the Loading state until either the creation is complete or an error occurs. The <a href="http://doc.qt.io/qt-5/qqmlincubator.html#statusChanged">statusChanged</a>() callback can be used to be notified of status changes.</p>
    /// <p>Applications should use the Asynchronous incubation mode to create objects that are not needed immediately. For example, the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> type uses Asynchronous incubation to create objects that are slightly off screen while the list is being scrolled. If, during asynchronous creation, the object is needed immediately the <a href="http://doc.qt.io/qt-5/qqmlincubator.html#forceCompletion">QQmlIncubator::forceCompletion</a>() method can be called to complete the creation process synchronously.</p>
    /// </li>
    /// <li><a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a> The creation will occur asynchronously if part of a nested asynchronous creation, or synchronously if not.<p>In most scenarios where a QML component wants the appearance of a synchronous instantiation, it should use this mode.</p>
    /// <p>This mode is best explained with an example. When the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> type is first created, it needs to populate itself with an initial set of delegates to show. If the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> was 400 pixels high, and each delegate was 100 pixels high, it would need to create four initial delegate instances. If the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> used the Asynchronous incubation mode, the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> would always be created empty and then, sometime later, the four initial items would appear.</p>
    /// <p>Conversely, if the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> was to use the Synchronous incubation mode it would behave correctly but it may introduce stutters into the application. As QML would have to stop and instantiate the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a>'s delegates synchronously, if the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> was part of a QML component that was being instantiated asynchronously this would undo much of the benefit of asynchronous instantiation.</p>
    /// <p>The <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a> mode reconciles this problem. By using <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a>, the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> delegates are instantiated asynchronously if the <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> itself is already part of an asynchronous instantiation, and synchronously otherwise. In the case of a nested asynchronous instantiation, the outer asynchronous instantiation will not complete until after all the nested instantiations have also completed. This ensures that by the time the outer asynchronous instantitation completes, inner items like <a href="http://doc.qt.io/qt-5/qml-qtquick-listview.html">ListView</a> have already completed loading their initial delegates.</p>
    /// <p>It is almost always incorrect to use the Synchronous incubation mode - elements or components that want the appearance of synchronous instantiation, but without the downsides of introducing freezes or stutters into the application, should use the <a href="http://doc.qt.io/qt-5/qqmlincubator.html#IncubationMode-enum">AsynchronousIfNested</a> incubation mode.</p>
    /// </li>
    /// </ul></div>
    #[inline(always)]
    pub unsafe fn new_0a() -> ::cpp_core::CppBox<crate::QQmlIncubator> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_QQmlIncubator1() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Return the incubated object if the status is Ready, otherwise 0.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlIncubator::object() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#object">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the incubated object if the status is Ready, otherwise 0.</p></div>
    #[inline(always)]
    pub unsafe fn object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_object(self as *const crate::QQmlIncubator)
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Return the current status of the incubator.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlIncubator::Status QQmlIncubator::status() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubator.html#status">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the current status of the incubator.</p></div>
    #[inline(always)]
    pub unsafe fn status(&self) -> crate::q_qml_incubator::Status {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_status(self as *const crate::QQmlIncubator)
    }
}

/// <p>In order to behave asynchronously and not introduce stutters or freezes in an application, the process of creating objects a QQmlIncubators must be driven only during the application's idle time. <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">QQmlIncubationController</a> allows the application to control exactly when, how often and for how long this processing occurs.</p>
///
/// C++ class: <span style='color: green;'>```QQmlIncubationController```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>In order to behave asynchronously and not introduce stutters or freezes in an application, the process of creating objects a QQmlIncubators must be driven only during the application's idle time. <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">QQmlIncubationController</a> allows the application to control exactly when, how often and for how long this processing occurs.</p>
/// <p>A <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html">QQmlIncubationController</a> derived instance should be created and set on a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> by calling the <a href="http://doc.qt.io/qt-5/qqmlengine.html#setIncubationController">QQmlEngine::setIncubationController</a>() method. Processing is then controlled by calling the <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html#incubateFor">QQmlIncubationController::incubateFor</a>() or <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html#incubateWhile">QQmlIncubationController::incubateWhile</a>() methods as dictated by the application's requirements.</p>
/// <p>For example, this is an example of a incubation controller that will incubate for a maximum of 5 milliseconds out of every 16 milliseconds.</p>
/// <pre class="cpp">
///
///   <span class="keyword">class</span> PeriodicIncubationController : <span class="keyword">public</span> <span class="type"><a href="http://doc.qt.io/qt-5/qobject.html">QObject</a></span><span class="operator">,</span>
/// &#32;   &#32;   &#32;   &#32;   &#32;   &#32;   &#32;   &#32;   &#32;      <span class="keyword">public</span> <span class="type">QQmlIncubationController</span>
///   {
///   <span class="keyword">public</span>:
/// &#32;     PeriodicIncubationController() {
/// &#32;   &#32;     startTimer(<span class="number">16</span>);
/// &#32;     }
///
///   <span class="keyword">protected</span>:
/// &#32;     <span class="type">void</span> timerEvent(<span class="type"><a href="http://doc.qt.io/qt-5/qtimerevent.html">QTimerEvent</a></span> <span class="operator">*</span>) override {
/// &#32;   &#32;     incubateFor(<span class="number">5</span>);
/// &#32;     }
///   };
///
/// </pre>
/// <p>Although the previous example would work, it is not optimal. Real world incubation controllers should try and maximize the amount of idle time they consume - rather than a static amount like 5 milliseconds - while not disturbing the application.</p></div>
#[repr(C)]
pub struct QQmlIncubationController {
    _unused: u8,
}
impl QQmlIncubationController {
    /// <p>Return the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> this incubation controller is set on, or 0 if it has not been set on any engine.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* QQmlIncubationController::engine() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html#engine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> this incubation controller is set on, or 0 if it has not been set on any engine.</p></div>
    #[inline(always)]
    pub unsafe fn engine(&self) -> ::qt_core::QPtr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlIncubationController_engine(
                self as *const crate::QQmlIncubationController,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Incubate objects for <i>msecs</i>, or until there are no more objects to incubate.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlIncubationController::incubateFor(int msecs)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html#incubateFor">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Incubate objects for <i>msecs</i>, or until there are no more objects to incubate.</p></div>
    #[inline(always)]
    pub unsafe fn incubate_for(&self, msecs: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubationController_incubateFor(
            self as *const crate::QQmlIncubationController as *mut crate::QQmlIncubationController,
            msecs,
        )
    }

    /// <p>Return the number of objects currently incubating.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlIncubationController::incubatingObjectCount() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html#incubatingObjectCount">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the number of objects currently incubating.</p></div>
    #[inline(always)]
    pub unsafe fn incubating_object_count(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubationController_incubatingObjectCount(
            self as *const crate::QQmlIncubationController,
        )
    }

    /// <p>Create a new incubation controller.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlIncubationController::QQmlIncubationController()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlincubationcontroller.html#QQmlIncubationController-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a new incubation controller.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QQmlIncubationController> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlIncubationController_QQmlIncubationController() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// C++ class: <span style='color: green;'>```QQmlInfo```</span>.
#[repr(C)]
pub struct QQmlInfo {
    _unused: u8,
}
impl QQmlInfo {
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator=(const QQmlInfo& other)```</span>.
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlInfo>>,
    ) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator_(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlInfo>>::cast_into(other)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlInfo::QQmlInfo(const QQmlInfo& arg1)```</span>.
    #[inline(always)]
    pub unsafe fn new_copy(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlInfo>>,
    ) -> ::cpp_core::CppBox<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_QQmlInfo(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlInfo>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(short t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_short(&self, t: ::std::os::raw::c_short) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__3(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(unsigned short t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_ushort(
        &self,
        t: ::std::os::raw::c_ushort,
    ) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__4(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(int t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_int(&self, t: ::std::os::raw::c_int) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__5(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(unsigned int t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_uint(&self, t: ::std::os::raw::c_uint) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__6(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(long t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_long(&self, t: ::std::os::raw::c_long) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__7(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(unsigned long t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_ulong(&self, t: ::std::os::raw::c_ulong) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__8(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(quint64 t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_u64(&self, t: u64) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__10(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(double t)```</span>.
    #[inline(always)]
    pub unsafe fn shl_double(
        &self,
        t: ::std::os::raw::c_double,
    ) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__12(
                self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                t,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }
}

/// <p>A QML engine uses QNetworkAccessManager for all network access. By implementing a factory, it is possible to provide the QML engine with custom QNetworkAccessManager instances with specialized caching, proxy and cookies support.</p>
///
/// C++ class: <span style='color: green;'>```QQmlNetworkAccessManagerFactory```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>A QML engine uses QNetworkAccessManager for all network access. By implementing a factory, it is possible to provide the QML engine with custom QNetworkAccessManager instances with specialized caching, proxy and cookies support.</p>
/// <p>To implement a factory, subclass <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html">QQmlNetworkAccessManagerFactory</a> and implement the virtual <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html#create">create</a>() method, then assign it to the relevant QML engine using <a href="http://doc.qt.io/qt-5/qqmlengine.html#setNetworkAccessManagerFactory">QQmlEngine::setNetworkAccessManagerFactory</a>().</p>
/// <p>Note the QML engine may create QNetworkAccessManager instances from multiple threads. Because of this, the implementation of the <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html#create">create</a>() method must be <a href="http://doc.qt.io/qt-5/qrandomgenerator.html#reentrancy-and-thread-safety">reentrant</a>. In addition, the developer should be careful if the signals of the object to be returned from <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html#create">create</a>() are connected to the slots of an object that may be created in a different thread:</p>
/// <ul>
/// <li>The QML engine internally handles all requests, and cleans up any QNetworkReply objects it creates. Receiving the QNetworkAccessManager::finished() signal in another thread may not provide the receiver with a valid reply object if it has already been deleted.</li>
/// <li>Authentication details provided to QNetworkAccessManager::authenticationRequired() must be provided immediately, so this signal cannot be connected as a <a href="http://doc.qt.io/qt-5/qt.html#ConnectionType-enum">Qt::QueuedConnection</a> (or as the default <a href="http://doc.qt.io/qt-5/qt.html#ConnectionType-enum">Qt::AutoConnection</a> from another thread).</li>
/// </ul>
/// <p>For more information about signals and threads, see <a href="http://doc.qt.io/qt-5/threads-qobject.html">Threads and QObjects</a> and <a href="http://doc.qt.io/qt-5/threads-qobject.html#signals-and-slots-across-threads">Signals and Slots Across Threads</a>.</p></div>
#[repr(C)]
pub struct QQmlNetworkAccessManagerFactory {
    _unused: u8,
}
impl QQmlNetworkAccessManagerFactory {
    /// <p>A QML engine uses QNetworkAccessManager for all network access. By implementing a factory, it is possible to provide the QML engine with custom QNetworkAccessManager instances with specialized caching, proxy and cookies support.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlNetworkAccessManagerFactory& QQmlNetworkAccessManagerFactory::operator=(const QQmlNetworkAccessManagerFactory& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>A QML engine uses QNetworkAccessManager for all network access. By implementing a factory, it is possible to provide the QML engine with custom QNetworkAccessManager instances with specialized caching, proxy and cookies support.</p>
    /// <p>To implement a factory, subclass <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html">QQmlNetworkAccessManagerFactory</a> and implement the virtual <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html#create">create</a>() method, then assign it to the relevant QML engine using <a href="http://doc.qt.io/qt-5/qqmlengine.html#setNetworkAccessManagerFactory">QQmlEngine::setNetworkAccessManagerFactory</a>().</p>
    /// <p>Note the QML engine may create QNetworkAccessManager instances from multiple threads. Because of this, the implementation of the <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html#create">create</a>() method must be <a href="http://doc.qt.io/qt-5/qrandomgenerator.html#reentrancy-and-thread-safety">reentrant</a>. In addition, the developer should be careful if the signals of the object to be returned from <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html#create">create</a>() are connected to the slots of an object that may be created in a different thread:</p>
    /// <ul>
    /// <li>The QML engine internally handles all requests, and cleans up any QNetworkReply objects it creates. Receiving the QNetworkAccessManager::finished() signal in another thread may not provide the receiver with a valid reply object if it has already been deleted.</li>
    /// <li>Authentication details provided to QNetworkAccessManager::authenticationRequired() must be provided immediately, so this signal cannot be connected as a <a href="http://doc.qt.io/qt-5/qt.html#ConnectionType-enum">Qt::QueuedConnection</a> (or as the default <a href="http://doc.qt.io/qt-5/qt.html#ConnectionType-enum">Qt::AutoConnection</a> from another thread).</li>
    /// </ul>
    /// <p>For more information about signals and threads, see <a href="http://doc.qt.io/qt-5/threads-qobject.html">Threads and QObjects</a> and <a href="http://doc.qt.io/qt-5/threads-qobject.html#signals-and-slots-across-threads">Signals and Slots Across Threads</a>.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlNetworkAccessManagerFactory>>,
    ) -> ::cpp_core::Ref<crate::QQmlNetworkAccessManagerFactory> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlNetworkAccessManagerFactory_operator_(self as *const crate::QQmlNetworkAccessManagerFactory as *mut crate::QQmlNetworkAccessManagerFactory, ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlNetworkAccessManagerFactory>>::cast_into(other).as_raw_ptr())
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }
}

pub mod q_qml_property {
    //! C++ type: <span style='color: green;'>```QQmlProperty```</span>

    /// <p>This enum specifies a category of QML property.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlProperty::PropertyTypeCategory```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#PropertyTypeCategory-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This enum specifies a category of QML property.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct PropertyTypeCategory(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for PropertyTypeCategory {
        fn from(value: ::std::os::raw::c_int) -> Self {
            PropertyTypeCategory(value)
        }
    }

    impl From<PropertyTypeCategory> for ::std::os::raw::c_int {
        fn from(value: PropertyTypeCategory) -> Self {
            value.0
        }
    }

    impl PropertyTypeCategory {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl PropertyTypeCategory {
        /// The property is invalid, or is a signal property. (C++ enum variant: <span style='color: green;'>```InvalidCategory = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const InvalidCategory: crate::q_qml_property::PropertyTypeCategory =
            crate::q_qml_property::PropertyTypeCategory(0);
        /// The property is a <a href="http://doc.qt.io/qt-5/qqmllistproperty.html">QQmlListProperty</a> list property (C++ enum variant: <span style='color: green;'>```List = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const List: crate::q_qml_property::PropertyTypeCategory =
            crate::q_qml_property::PropertyTypeCategory(1);
        /// The property is a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> derived type pointer (C++ enum variant: <span style='color: green;'>```Object = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const Object: crate::q_qml_property::PropertyTypeCategory =
            crate::q_qml_property::PropertyTypeCategory(2);
        /// The property is a normal value property. (C++ enum variant: <span style='color: green;'>```Normal = 3```</span>)
        #[allow(non_upper_case_globals)]
        pub const Normal: crate::q_qml_property::PropertyTypeCategory =
            crate::q_qml_property::PropertyTypeCategory(3);
    }

    /// <p>This enum specifies a type of QML property.</p>
    ///
    /// C++ enum: <span style='color: green;'>```QQmlProperty::Type```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#Type-enum">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This enum specifies a type of QML property.</p></div>
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct Type(::std::os::raw::c_int);

    impl From<::std::os::raw::c_int> for Type {
        fn from(value: ::std::os::raw::c_int) -> Self {
            Type(value)
        }
    }

    impl From<Type> for ::std::os::raw::c_int {
        fn from(value: Type) -> Self {
            value.0
        }
    }

    impl Type {
        pub fn to_int(&self) -> ::std::os::raw::c_int {
            self.0
        }
    }

    impl Type {
        /// The property is invalid. (C++ enum variant: <span style='color: green;'>```Invalid = 0```</span>)
        #[allow(non_upper_case_globals)]
        pub const Invalid: crate::q_qml_property::Type = crate::q_qml_property::Type(0);
        /// The property is a regular Qt property. (C++ enum variant: <span style='color: green;'>```Property = 1```</span>)
        #[allow(non_upper_case_globals)]
        pub const Property: crate::q_qml_property::Type = crate::q_qml_property::Type(1);
        /// The property is a signal property. (C++ enum variant: <span style='color: green;'>```SignalProperty = 2```</span>)
        #[allow(non_upper_case_globals)]
        pub const SignalProperty: crate::q_qml_property::Type = crate::q_qml_property::Type(2);
    }
}
/// <p>As QML uses Qt's meta-type system all of the existing <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> classes can be used to introspect and interact with objects created by QML. However, some of the new features provided by QML - such as type safety and attached properties - are most easily used through the <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> class that simplifies some of their natural complexity.</p>
///
/// C++ class: <span style='color: green;'>```QQmlProperty```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlproperty.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>As QML uses Qt's meta-type system all of the existing <a href="http://doc.qt.io/qt-5/qmetaobject.html">QMetaObject</a> classes can be used to introspect and interact with objects created by QML. However, some of the new features provided by QML - such as type safety and attached properties - are most easily used through the <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> class that simplifies some of their natural complexity.</p>
/// <p>Unlike <a href="http://doc.qt.io/qt-5/qmetaproperty.html">QMetaProperty</a> which represents a property on a class type, <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> encapsulates a property on a specific object instance. To read a property's value, programmers create a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> instance and call the <a href="http://doc.qt.io/qt-5/qqmlproperty.html#read">read</a>() method. Likewise to write a property value the <a href="http://doc.qt.io/qt-5/qqmlproperty.html#write">write</a>() method is used.</p>
/// <p>For example, for the following QML code:</p>
/// <pre class="qml">
///
///   <span class="comment">// MyItem.qml</span>
///   import QtQuick 2.0
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qml-qtquick-text.html">Text</a></span> { <span class="name">text</span>: <span class="string">"A bit of text"</span> }
///
/// </pre>
/// <p>The <a href="http://doc.qt.io/qt-5/qml-qtquick-text.html">Text</a> object's properties could be accessed using <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a>, like this:</p>
/// <pre class="cpp">
///
///   <span class="preprocessor">#include &lt;QQmlProperty&gt;</span>
///   <span class="preprocessor">#include &lt;QGraphicsObject&gt;</span>
///
///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qquickview.html">QQuickView</a></span> view(<span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"MyItem.qml"</span>));
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">QQmlProperty</a></span> property(view<span class="operator">.</span>rootObject()<span class="operator">,</span> <span class="string">"font.pixelSize"</span>);
///   <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"Current pixel size:"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> property<span class="operator">.</span>read()<span class="operator">.</span>toInt();
///   property<span class="operator">.</span>write(<span class="number">24</span>);
///   <a href="http://doc.qt.io/qt-5/#qWarning">qWarning</a>() <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"Pixel size should now be 24:"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> property<span class="operator">.</span>read()<span class="operator">.</span>toInt();
///
/// </pre></div>
#[repr(C)]
pub struct QQmlProperty {
    _unused: u8,
}
impl QQmlProperty {
    /// <p>Connects the property's change notifier signal to the specified <i>slot</i> of the <i>dest</i> object and returns true. Returns false if this metaproperty does not represent a regular Qt property or if it has no change notifier signal, or if the <i>dest</i> object does not have the specified <i>slot</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::connectNotifySignal(QObject* dest, const char* slot) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#connectNotifySignal">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Connects the property's change notifier signal to the specified <i>slot</i> of the <i>dest</i> object and returns true. Returns false if this metaproperty does not represent a regular Qt property or if it has no change notifier signal, or if the <i>dest</i> object does not have the specified <i>slot</i>.</p>
    /// <p><b>Note: </b><i>slot</i> should be passed using the SLOT() macro so it is correctly identified.</p></div>
    #[inline(always)]
    pub unsafe fn connect_notify_signal_q_object_char(
        &self,
        dest: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        slot: *const ::std::os::raw::c_char,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_connectNotifySignal(
            self as *const crate::QQmlProperty,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(dest)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            slot,
        )
    }

    /// <p>Connects the property's change notifier signal to the specified <i>method</i> of the <i>dest</i> object and returns true. Returns false if this metaproperty does not represent a regular Qt property or if it has no change notifier signal, or if the <i>dest</i> object does not have the specified <i>method</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::connectNotifySignal(QObject* dest, int method) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#connectNotifySignal-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Connects the property's change notifier signal to the specified <i>method</i> of the <i>dest</i> object and returns true. Returns false if this metaproperty does not represent a regular Qt property or if it has no change notifier signal, or if the <i>dest</i> object does not have the specified <i>method</i>.</p></div>
    #[inline(always)]
    pub unsafe fn connect_notify_signal_q_object_int(
        &self,
        dest: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        method: ::std::os::raw::c_int,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_connectNotifySignal1(
            self as *const crate::QQmlProperty,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(dest)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            method,
        )
    }

    /// <p>Assign <i>other</i> to this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlProperty& QQmlProperty::operator=(const QQmlProperty& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assign <i>other</i> to this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a>.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlProperty>>,
    ) -> ::cpp_core::Ref<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_operator_(
                self as *const crate::QQmlProperty as *mut crate::QQmlProperty,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlProperty>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns true if the property has a change notifier signal, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::hasNotifySignal() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#hasNotifySignal">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the property has a change notifier signal, otherwise false.</p></div>
    #[inline(always)]
    pub unsafe fn has_notify_signal(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_hasNotifySignal(
            self as *const crate::QQmlProperty,
        )
    }

    /// <p>Return the Qt metaobject index of the property.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlProperty::index() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#index">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the Qt metaobject index of the property.</p></div>
    #[inline(always)]
    pub unsafe fn index(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_index(self as *const crate::QQmlProperty)
    }

    /// <p>Returns true if the property is designable, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::isDesignable() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#isDesignable">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the property is designable, otherwise false.</p></div>
    #[inline(always)]
    pub unsafe fn is_designable(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_isDesignable(self as *const crate::QQmlProperty)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> represents a regular Qt property.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::isProperty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#isProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> represents a regular Qt property.</p></div>
    #[inline(always)]
    pub unsafe fn is_property(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_isProperty(self as *const crate::QQmlProperty)
    }

    /// <p>Returns true if the property is resettable, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::isResettable() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#isResettable">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the property is resettable, otherwise false.</p></div>
    #[inline(always)]
    pub unsafe fn is_resettable(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_isResettable(self as *const crate::QQmlProperty)
    }

    /// <p>Returns true if this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> represents a QML signal property.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::isSignalProperty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#isSignalProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> represents a QML signal property.</p></div>
    #[inline(always)]
    pub unsafe fn is_signal_property(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_isSignalProperty(
            self as *const crate::QQmlProperty,
        )
    }

    /// <p>Returns true if the <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> refers to a valid property, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::isValid() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#isValid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> refers to a valid property, otherwise false.</p></div>
    #[inline(always)]
    pub unsafe fn is_valid(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_isValid(self as *const crate::QQmlProperty)
    }

    /// <p>Returns true if the property is writable, otherwise false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::isWritable() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#isWritable">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the property is writable, otherwise false.</p></div>
    #[inline(always)]
    pub unsafe fn is_writable(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_isWritable(self as *const crate::QQmlProperty)
    }

    /// <p>Return the <a href="http://doc.qt.io/qt-5/qmetamethod.html">QMetaMethod</a> for this property if it is a <a href="http://doc.qt.io/qt-5/qqmlproperty.html#Type-enum">SignalProperty</a>, otherwise returns an invalid <a href="http://doc.qt.io/qt-5/qmetamethod.html">QMetaMethod</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QMetaMethod QQmlProperty::method() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#method">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the <a href="http://doc.qt.io/qt-5/qmetamethod.html">QMetaMethod</a> for this property if it is a <a href="http://doc.qt.io/qt-5/qqmlproperty.html#Type-enum">SignalProperty</a>, otherwise returns an invalid <a href="http://doc.qt.io/qt-5/qmetamethod.html">QMetaMethod</a>.</p></div>
    #[inline(always)]
    pub unsafe fn method(&self) -> ::cpp_core::CppBox<::qt_core::QMetaMethod> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_method(self as *const crate::QQmlProperty)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Return the name of this QML property.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QString QQmlProperty::name() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#name">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the name of this QML property.</p></div>
    #[inline(always)]
    pub unsafe fn name(&self) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_name(self as *const crate::QQmlProperty) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns true if the property needs a change notifier signal for bindings to remain upto date, false otherwise.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::needsNotifySignal() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#needsNotifySignal">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the property needs a change notifier signal for bindings to remain upto date, false otherwise.</p>
    /// <p>Some properties, such as attached properties or those whose value never changes, do not require a change notifier.</p></div>
    #[inline(always)]
    pub unsafe fn needs_notify_signal(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_needsNotifySignal(
            self as *const crate::QQmlProperty,
        )
    }

    /// <p>Create an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the default property of <i>obj</i>. If there is no default property, an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> will be created.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty(QObject* arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the default property of <i>obj</i>. If there is no default property, an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> will be created.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_object(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the default property of <i>obj</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>. If there is no default property, an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> will be created.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty(QObject* arg1, QQmlContext* arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the default property of <i>obj</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>. If there is no default property, an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> will be created.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_object_q_qml_context(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty2(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg2)
                    .as_raw_ptr() as *mut crate::QQmlContext,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the default property of <i>obj</i> using the environment for instantiating QML components that is provided by <i>engine</i>. If there is no default property, an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> will be created.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty(QObject* arg1, QQmlEngine* arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty-3">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the default property of <i>obj</i> using the environment for instantiating QML components that is provided by <i>engine</i>. If there is no default property, an invalid <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> will be created.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_object_q_qml_engine(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty3(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg2)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the property <i>name</i> of <i>obj</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty(QObject* arg1, const QString& arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty-4">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the property <i>name</i> of <i>obj</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_object_q_string(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty4(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the property <i>name</i> of <i>obj</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty(QObject* arg1, const QString& arg2, QQmlContext* arg3)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty-5">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the property <i>name</i> of <i>obj</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>.</p>
    /// <p>Creating a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> without a context will render some properties - like attached properties - inaccessible.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_object_q_string_q_qml_context(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty5(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg3)
                    .as_raw_ptr() as *mut crate::QQmlContext,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the property <i>name</i> of <i>obj</i> using the environment for instantiating QML components that is provided by <i>engine</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty(QObject* arg1, const QString& arg2, QQmlEngine* arg3)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty-6">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Creates a <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> for the property <i>name</i> of <i>obj</i> using the environment for instantiating QML components that is provided by <i>engine</i>.</p></div>
    #[inline(always)]
    pub unsafe fn from_q_object_q_string_q_qml_engine(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty6(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg3)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Create a copy of <i>other</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlProperty::QQmlProperty(const QQmlProperty& arg1)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty-7">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Create a copy of <i>other</i>.</p></div>
    #[inline(always)]
    pub unsafe fn new_copy(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlProperty>>,
    ) -> ::cpp_core::CppBox<crate::QQmlProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_QQmlProperty7(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlProperty>>::cast_into(arg1)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a>'s <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QQmlProperty::object() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#object">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a>'s <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p></div>
    #[inline(always)]
    pub unsafe fn object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_object(self as *const crate::QQmlProperty)
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qmetaproperty.html">Qt property</a> associated with this QML property.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QMetaProperty QQmlProperty::property() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#property">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qmetaproperty.html">Qt property</a> associated with this QML property.</p></div>
    #[inline(always)]
    pub unsafe fn property(&self) -> ::cpp_core::CppBox<::qt_core::QMetaProperty> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_property(self as *const crate::QQmlProperty)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> type of the property, or QVariant::Invalid if the property has no <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> type.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlProperty::propertyType() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#propertyType">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> type of the property, or QVariant::Invalid if the property has no <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> type.</p></div>
    #[inline(always)]
    pub unsafe fn property_type(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_propertyType(self as *const crate::QQmlProperty)
    }

    /// <p>Returns the property category.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlProperty::PropertyTypeCategory QQmlProperty::propertyTypeCategory() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#propertyTypeCategory">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the property category.</p></div>
    #[inline(always)]
    pub unsafe fn property_type_category(&self) -> crate::q_qml_property::PropertyTypeCategory {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_propertyTypeCategory(
            self as *const crate::QQmlProperty,
        )
    }

    /// <p>Returns the type name of the property, or 0 if the property has no type name.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const char* QQmlProperty::propertyTypeName() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#propertyTypeName">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the type name of the property, or 0 if the property has no type name.</p></div>
    #[inline(always)]
    pub unsafe fn property_type_name(&self) -> *const ::std::os::raw::c_char {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_propertyTypeName(
            self as *const crate::QQmlProperty,
        )
    }

    /// <p>Returns the property value.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant QQmlProperty::read() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#read">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the property value.</p></div>
    #[inline(always)]
    pub unsafe fn read(&self) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_read(self as *const crate::QQmlProperty) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Return the <i>name</i> property value of <i>object</i>. This method is equivalent to:</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QVariant QQmlProperty::read(const QObject* arg1, const QString& arg2)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#read-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the <i>name</i> property value of <i>object</i>. This method is equivalent to:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">QQmlProperty</a></span> p(object<span class="operator">,</span> name);
    ///   p<span class="operator">.</span>read();
    ///
    /// </pre></div>
    #[inline(always)]
    pub unsafe fn read_q_object_q_string(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_read1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Return the <i>name</i> property value of <i>object</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>. This method is equivalent to:</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QVariant QQmlProperty::read(const QObject* arg1, const QString& arg2, QQmlContext* arg3)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#read-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the <i>name</i> property value of <i>object</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>. This method is equivalent to:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">QQmlProperty</a></span> p(object<span class="operator">,</span> name<span class="operator">,</span> context);
    ///   p<span class="operator">.</span>read();
    ///
    /// </pre></div>
    #[inline(always)]
    pub unsafe fn read_q_object_q_string_q_qml_context(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_read2(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg3)
                    .as_raw_ptr() as *mut crate::QQmlContext,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Return the <i>name</i> property value of <i>object</i> using the environment for instantiating QML components that is provided by <i>engine</i>. . This method is equivalent to:</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static QVariant QQmlProperty::read(const QObject* arg1, const QString& arg2, QQmlEngine* arg3)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#read-3">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Return the <i>name</i> property value of <i>object</i> using the environment for instantiating QML components that is provided by <i>engine</i>. . This method is equivalent to:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">QQmlProperty</a></span> p(object<span class="operator">,</span> name<span class="operator">,</span> engine);
    ///   p<span class="operator">.</span>read();
    ///
    /// </pre></div>
    #[inline(always)]
    pub unsafe fn read_q_object_q_string_q_qml_engine(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_read3(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                    .as_raw_ptr(),
                ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg3)
                    .as_raw_ptr() as *mut crate::QQmlEngine,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Resets the property and returns true if the property is resettable. If the property is not resettable, nothing happens and false is returned.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::reset() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#reset">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Resets the property and returns true if the property is resettable. If the property is not resettable, nothing happens and false is returned.</p></div>
    #[inline(always)]
    pub unsafe fn reset(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_reset(self as *const crate::QQmlProperty)
    }

    /// <p>Returns the type of the property.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlProperty::Type QQmlProperty::type() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#type">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the type of the property.</p></div>
    #[inline(always)]
    pub unsafe fn type_(&self) -> crate::q_qml_property::Type {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_type(self as *const crate::QQmlProperty)
    }

    /// <p>Sets the property value to <i>value</i>. Returns <code>true</code> on success, or <code>false</code> if the property can't be set because the <i>value</i> is the wrong type, for example.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::write(const QVariant& arg1) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#write">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the property value to <i>value</i>. Returns <code>true</code> on success, or <code>false</code> if the property can't be set because the <i>value</i> is the wrong type, for example.</p></div>
    #[inline(always)]
    pub unsafe fn write_q_variant(
        &self,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_write(
            self as *const crate::QQmlProperty,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(arg1)
                .as_raw_ptr(),
        )
    }

    /// <p>Writes <i>value</i> to the <i>name</i> property of <i>object</i>. This method is equivalent to:</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlProperty::write(QObject* arg1, const QString& arg2, const QVariant& arg3)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#write-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Writes <i>value</i> to the <i>name</i> property of <i>object</i>. This method is equivalent to:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">QQmlProperty</a></span> p(object<span class="operator">,</span> name);
    ///   p<span class="operator">.</span>write(value);
    ///
    /// </pre>
    /// <p>Returns <code>true</code> on success, <code>false</code> otherwise.</p></div>
    #[inline(always)]
    pub unsafe fn write_q_object_q_string_q_variant(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_write1(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(arg3)
                .as_raw_ptr(),
        )
    }

    /// <p>Writes <i>value</i> to the <i>name</i> property of <i>object</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>. This method is equivalent to:</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlProperty::write(QObject* arg1, const QString& arg2, const QVariant& arg3, QQmlContext* arg4)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#write-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Writes <i>value</i> to the <i>name</i> property of <i>object</i> using the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">context</a> <i>ctxt</i>. This method is equivalent to:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">QQmlProperty</a></span> p(object<span class="operator">,</span> name<span class="operator">,</span> ctxt);
    ///   p<span class="operator">.</span>write(value);
    ///
    /// </pre>
    /// <p>Returns <code>true</code> on success, <code>false</code> otherwise.</p></div>
    #[inline(always)]
    pub unsafe fn write_q_object_q_string_q_variant_q_qml_context(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
        arg4: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlContext>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_write2(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(arg3)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlContext>>::cast_into(arg4)
                .as_raw_ptr() as *mut crate::QQmlContext,
        )
    }

    /// <p>Writes <i>value</i> to the <i>name</i> property of <i>object</i> using the environment for instantiating QML components that is provided by <i>engine</i>. This method is equivalent to:</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```static bool QQmlProperty::write(QObject* arg1, const QString& arg2, const QVariant& arg3, QQmlEngine* arg4)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#write-3">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Writes <i>value</i> to the <i>name</i> property of <i>object</i> using the environment for instantiating QML components that is provided by <i>engine</i>. This method is equivalent to:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlproperty.html#QQmlProperty">QQmlProperty</a></span> p(object<span class="operator">,</span> name<span class="operator">,</span> engine);
    ///   p<span class="operator">.</span>write(value);
    ///
    /// </pre>
    /// <p>Returns <code>true</code> on success, <code>false</code> otherwise.</p></div>
    #[inline(always)]
    pub unsafe fn write_q_object_q_string_q_variant_q_qml_engine(
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg2: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg3: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
        arg4: impl ::cpp_core::CastInto<::cpp_core::Ptr<crate::QQmlEngine>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_write3(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg2)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(arg3)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ptr<crate::QQmlEngine>>::cast_into(arg4).as_raw_ptr()
                as *mut crate::QQmlEngine,
        )
    }
}

/// <p><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">QQmlPropertyMap</a> provides a convenient way to expose domain data to the UI layer. The following example shows how you might declare data in C++ and then access it in QML.</p>
///
/// C++ class: <span style='color: green;'>```QQmlPropertyMap```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">QQmlPropertyMap</a> provides a convenient way to expose domain data to the UI layer. The following example shows how you might declare data in C++ and then access it in QML.</p>
/// <p>In the C++ file:</p>
/// <pre class="cpp">
///
///   <span class="comment">// create our data</span>
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#QQmlPropertyMap">QQmlPropertyMap</a></span> ownerData;
///   ownerData<span class="operator">.</span>insert(<span class="string">"name"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a></span>(<span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span>(<span class="string">"John Smith"</span>)));
///   ownerData<span class="operator">.</span>insert(<span class="string">"phone"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a></span>(<span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span>(<span class="string">"555-5555"</span>)));
///
///   <span class="comment">// expose it to the UI layer</span>
///   <span class="type"><a href="http://doc.qt.io/qt-5/qquickview.html">QQuickView</a></span> view;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a></span> <span class="operator">*</span>ctxt <span class="operator">=</span> view<span class="operator">.</span>rootContext();
///   ctxt<span class="operator">-</span><span class="operator">&gt;</span>setContextProperty(<span class="string">"owner"</span><span class="operator">,</span> <span class="operator">&amp;</span>ownerData);
///
///   view<span class="operator">.</span>setSource(<span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"main.qml"</span>));
///   view<span class="operator">.</span>show();
///
/// </pre>
/// <p>Then, in <code>main.qml</code>:</p>
/// <pre class="cpp">
///
///   Text { text: owner<span class="operator">.</span>name <span class="operator">+</span> <span class="string">" "</span> <span class="operator">+</span> owner<span class="operator">.</span>phone }
///
/// </pre>
/// <p>The binding is dynamic - whenever a key's value is updated, anything bound to that key will be updated as well.</p>
/// <p>To detect value changes made in the UI layer you can connect to the <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#valueChanged">valueChanged</a>() signal. However, note that <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#valueChanged">valueChanged</a>() is <b>NOT</b> emitted when changes are made by calling <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#insert">insert</a>() or <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#clear">clear</a>() - it is only emitted when a value is updated from QML.</p>
/// <p><b>Note: </b>It is not possible to remove keys from the map; once a key has been added, you can only modify or clear its associated value.</p><p><b>Note: </b>When deriving a class from <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">QQmlPropertyMap</a>, use the <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#QQmlPropertyMap-1">protected two-argument constructor</a> which ensures that the class is correctly registered with the Qt <a href="http://doc.qt.io/qt-5/metaobjects.html">Meta-Object System</a>.</p></div>
#[repr(C)]
pub struct QQmlPropertyMap {
    _unused: u8,
}
impl QQmlPropertyMap {
    /// <p>This signal is emitted whenever one of the values in the map is changed. <i>key</i> is the key corresponding to the <i>value</i> that was changed.</p>
    ///
    /// Returns a built-in Qt signal `QQmlPropertyMap::valueChanged` that can be passed to `qt_core::Signal::connect`.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#valueChanged">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This signal is emitted whenever one of the values in the map is changed. <i>key</i> is the key corresponding to the <i>value</i> that was changed.</p>
    /// <p><b>Note: </b>valueChanged() is <b>NOT</b> emitted when changes are made by calling <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#insert">insert</a>() or <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#clear">clear</a>() - it is only emitted when a value is updated from QML.</p></div>
    #[inline(always)]
    pub fn value_changed(
        &self,
    ) -> ::qt_core::Signal<(*const ::qt_core::QString, *const ::qt_core::QVariant)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2valueChanged(QString const &,QVariant const &)\0",
                ),
            )
        }
    }

    /// <p>Clears the value (if any) associated with <i>key</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlPropertyMap::clear(const QString& key)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#clear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Clears the value (if any) associated with <i>key</i>.</p></div>
    #[inline(always)]
    pub unsafe fn clear(
        &self,
        key: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_clear(
            self as *const crate::QQmlPropertyMap as *mut crate::QQmlPropertyMap,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(key)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns true if the map contains <i>key</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlPropertyMap::contains(const QString& key) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#contains">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the map contains <i>key</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#size">size</a>().</p></div>
    #[inline(always)]
    pub unsafe fn contains(
        &self,
        key: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_contains(
            self as *const crate::QQmlPropertyMap,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(key)
                .as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlPropertyMap::count() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#count">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Same as <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#size">size</a>().</p></div>
    #[inline(always)]
    pub unsafe fn count(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_count(self as *const crate::QQmlPropertyMap)
    }

    /// <p>Returns the value associated with the key <i>key</i> as a modifiable reference.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant& QQmlPropertyMap::operator[](const QString& key)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#operator-5b-5d">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value associated with the key <i>key</i> as a modifiable reference.</p>
    /// <p>If the map contains no item with key <i>key</i>, the function inserts an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> into the map with key <i>key</i>, and returns a reference to it.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#insert">insert</a>() and <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#value">value</a>().</p></div>
    #[inline(always)]
    pub unsafe fn index_mut(
        &self,
        key: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::Ref<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_operator__(
                self as *const crate::QQmlPropertyMap as *mut crate::QQmlPropertyMap,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(key)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant QQmlPropertyMap::operator[](const QString& key) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#operator-5b-5d-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Same as <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#value">value</a>().</p></div>
    #[inline(always)]
    pub unsafe fn index(
        &self,
        key: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_operator__1(
                self as *const crate::QQmlPropertyMap,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(key)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Sets the value associated with <i>key</i> to <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QQmlPropertyMap::insert(const QString& key, const QVariant& value)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#insert">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the value associated with <i>key</i> to <i>value</i>.</p>
    /// <p>If the key doesn't exist, it is automatically created.</p></div>
    #[inline(always)]
    pub unsafe fn insert(
        &self,
        key: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        value: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_insert(
            self as *const crate::QQmlPropertyMap as *mut crate::QQmlPropertyMap,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(key)
                .as_raw_ptr(),
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(value)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns true if the map contains no keys; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlPropertyMap::isEmpty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#isEmpty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if the map contains no keys; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#size">size</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_isEmpty(self as *const crate::QQmlPropertyMap)
    }

    /// <p>Returns the list of keys.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QStringList QQmlPropertyMap::keys() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#keys">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the list of keys.</p>
    /// <p>Keys that have been cleared will still appear in this list, even though their associated values are invalid QVariants.</p>
    /// <p><b>Note: </b>This function can be invoked via the meta-object system and from QML. See <a href="http://doc.qt.io/qt-5/qobject.html#Q_INVOKABLE">Q_INVOKABLE</a>.</p></div>
    #[inline(always)]
    pub unsafe fn keys(&self) -> ::cpp_core::CppBox<::qt_core::QStringList> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_keys(self as *const crate::QQmlPropertyMap)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```virtual const QMetaObject* QQmlPropertyMap::metaObject() const```</span>.
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_metaObject(
                self as *const crate::QQmlPropertyMap,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// <p>Constructs a bindable map with parent object <i>parent</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlPropertyMap::QQmlPropertyMap(QObject* parent = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#QQmlPropertyMap">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a bindable map with parent object <i>parent</i>.</p></div>
    #[inline(always)]
    pub unsafe fn new_1a(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::qt_core::QBox<crate::QQmlPropertyMap> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_QQmlPropertyMap(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// <p><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">QQmlPropertyMap</a> provides a convenient way to expose domain data to the UI layer. The following example shows how you might declare data in C++ and then access it in QML.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QQmlPropertyMap::QQmlPropertyMap()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">QQmlPropertyMap</a> provides a convenient way to expose domain data to the UI layer. The following example shows how you might declare data in C++ and then access it in QML.</p>
    /// <p>In the C++ file:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="comment">// create our data</span>
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#QQmlPropertyMap">QQmlPropertyMap</a></span> ownerData;
    ///   ownerData<span class="operator">.</span>insert(<span class="string">"name"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a></span>(<span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span>(<span class="string">"John Smith"</span>)));
    ///   ownerData<span class="operator">.</span>insert(<span class="string">"phone"</span><span class="operator">,</span> <span class="type"><a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a></span>(<span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span>(<span class="string">"555-5555"</span>)));
    ///
    ///   <span class="comment">// expose it to the UI layer</span>
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qquickview.html">QQuickView</a></span> view;
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a></span> <span class="operator">*</span>ctxt <span class="operator">=</span> view<span class="operator">.</span>rootContext();
    ///   ctxt<span class="operator">-</span><span class="operator">&gt;</span>setContextProperty(<span class="string">"owner"</span><span class="operator">,</span> <span class="operator">&amp;</span>ownerData);
    ///
    ///   view<span class="operator">.</span>setSource(<span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span><span class="operator">::</span>fromLocalFile(<span class="string">"main.qml"</span>));
    ///   view<span class="operator">.</span>show();
    ///
    /// </pre>
    /// <p>Then, in <code>main.qml</code>:</p>
    /// <pre class="cpp">
    ///
    ///   Text { text: owner<span class="operator">.</span>name <span class="operator">+</span> <span class="string">" "</span> <span class="operator">+</span> owner<span class="operator">.</span>phone }
    ///
    /// </pre>
    /// <p>The binding is dynamic - whenever a key's value is updated, anything bound to that key will be updated as well.</p>
    /// <p>To detect value changes made in the UI layer you can connect to the <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#valueChanged">valueChanged</a>() signal. However, note that <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#valueChanged">valueChanged</a>() is <b>NOT</b> emitted when changes are made by calling <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#insert">insert</a>() or <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#clear">clear</a>() - it is only emitted when a value is updated from QML.</p>
    /// <p><b>Note: </b>It is not possible to remove keys from the map; once a key has been added, you can only modify or clear its associated value.</p><p><b>Note: </b>When deriving a class from <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html">QQmlPropertyMap</a>, use the <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#QQmlPropertyMap-1">protected two-argument constructor</a> which ensures that the class is correctly registered with the Qt <a href="http://doc.qt.io/qt-5/metaobjects.html">Meta-Object System</a>.</p></div>
    #[inline(always)]
    pub unsafe fn new_0a() -> ::qt_core::QBox<crate::QQmlPropertyMap> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_QQmlPropertyMap1() };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    /// Calls C++ function: <span style='color: green;'>```virtual int QQmlPropertyMap::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_qt_metacall(
            self as *const crate::QQmlPropertyMap as *mut crate::QQmlPropertyMap,
            arg1,
            arg2,
            arg3,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```virtual void* QQmlPropertyMap::qt_metacast(const char* arg1)```</span>.
    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_qt_metacast(
            self as *const crate::QQmlPropertyMap as *mut crate::QQmlPropertyMap,
            arg1,
        )
    }

    /// <p>Returns the number of keys in the map.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlPropertyMap::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of keys in the map.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#count">count</a>().</p></div>
    #[inline(always)]
    pub unsafe fn size(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_size(self as *const crate::QQmlPropertyMap)
    }

    /// Returns a reference to the <span style='color: green;'>```staticMetaObject```</span> field.
    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_staticMetaObject() };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlPropertyMap::tr(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_tr(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```static QString QQmlPropertyMap::trUtf8(const char* s, const char* c, int n)```</span>.
    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_trUtf8(s, c, n) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the value associated with <i>key</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVariant QQmlPropertyMap::value(const QString& key) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#value">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value associated with <i>key</i>.</p>
    /// <p>If no value has been set for this key (or if the value has been cleared), an invalid <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a> is returned.</p></div>
    #[inline(always)]
    pub unsafe fn value(
        &self,
        key: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
    ) -> ::cpp_core::CppBox<::qt_core::QVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_value(
                self as *const crate::QQmlPropertyMap,
                ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(key)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_list_of_q_j_s_value {
    //! C++ type: <span style='color: green;'>```QList<QJSValue>```</span>

    /// <p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    ///
    /// C++ class: <span style='color: green;'>```QList<QJSValue>::iterator```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> features both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;) and to modify the list item associated with the iterator. If you want to iterate over a const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>, use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
    /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
    ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
    ///
    /// </pre>
    /// <p>Let's see a few examples of things we can do with a <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> that we cannot do with a <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a>. Here's an example that increments every value stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;int&gt; by 2:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
    ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     <span class="operator">*</span>i <span class="operator">+</span><span class="operator">=</span> <span class="number">2</span>;
    ///
    /// </pre>
    /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
    /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>begin()<span class="operator">,</span> list<span class="operator">.</span>end());
    ///
    /// </pre>
    /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
    #[repr(C)]
    pub struct Iterator {
        _unused: u8,
    }
    impl Iterator {
        /// <p>Advances the iterator by <i>j</i> items. (If <i>j</i> is negative, the iterator goes backward.)</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator& QList<QJSValue>::iterator::operator+=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-eq">C++ documentation</a> for <span style='color: green;'>```iterator &iterator::operator+=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Advances the iterator by <i>j</i> items. (If <i>j</i> is negative, the iterator goes backward.)</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--eq">operator-=</a>() and <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn add_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__14(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator& QList<QJSValue>::iterator::operator=(const QList<QJSValue>::iterator& other)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> features both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;) and to modify the list item associated with the iterator. If you want to iterate over a const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>, use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Let's see a few examples of things we can do with a <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> that we cannot do with a <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a>. Here's an example that increments every value stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;int&gt; by 2:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     <span class="operator">*</span>i <span class="operator">+</span><span class="operator">=</span> <span class="number">2</span>;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>begin()<span class="operator">,</span> list<span class="operator">.</span>end());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        pub unsafe fn copy_from(
            &self,
            other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_8(self as *const crate::q_list_of_q_j_s_value::Iterator as *mut crate::q_list_of_q_j_s_value::Iterator, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>::cast_into(other).as_raw_ptr())
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator& QList<QJSValue>::iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#begin">QHash::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        pub unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__12(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::iterator::operator--(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator---1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix -- operator (<code>i--</code>) makes the preceding item current and returns an iterator pointing to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn dec_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__13(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator& QList<QJSValue>::iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#end">QHash::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        pub unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__10(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::iterator::operator++(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix ++ operator (<code>i++</code>) advances the iterator to the next item in the hash and returns an iterator to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn inc_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__11(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns a modifiable reference to the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::iterator::operator[](long long j) const```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-5b-5d">C++ documentation</a> for <span style='color: green;'>```QJsonValueRef iterator::operator[](int j) const```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a modifiable reference to the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        /// <p>This function is provided to make <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> iterators behave like C++ pointers.</p>
        /// <p>The return value is of type <a href="http://doc.qt.io/qt-5/qjsonvalue.html#qjsonvalueref">QJsonValueRef</a>, a helper class for <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> and <a href="http://doc.qt.io/qt-5/qjsonobject.html">QJsonObject</a>. When you get an object of type <a href="http://doc.qt.io/qt-5/qjsonvalue.html#qjsonvalueref">QJsonValueRef</a>, you can use it as if it were a reference to a <a href="http://doc.qt.io/qt-5/qjsonvalue.html">QJsonValue</a>. If you assign to it, the assignment will apply to the character in the <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> of <a href="http://doc.qt.io/qt-5/qjsonobject.html">QJsonObject</a> from which you got the reference.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn index(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__1(
                    self as *const crate::q_list_of_q_j_s_value::Iterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>Returns a modifiable reference to the current item's value.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a modifiable reference to the current item's value.</p>
        /// <p>Same as <a href="http://doc.qt.io/qt-5/qhash-iterator.html#value">value</a>().</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#key">key</a>().</p></div>
        #[inline(always)]
        pub unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_(
                    self as *const crate::q_list_of_q_j_s_value::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>Constructs an uninitialized iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::iterator::iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html#iterator">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an uninitialized iterator.</p>
        /// <p>Functions like operator*() and operator++() should not be called on an uninitialized iterator. Use operator=() to assign a value to it before using it.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>().</p></div>
        #[inline(always)]
        pub unsafe fn new() -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_iterator() };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::iterator::iterator(const QList<QJSValue>::iterator& o)```</span>.
        #[inline(always)]
        pub unsafe fn new_copy(
            o: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_iterator1(::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>::cast_into(o).as_raw_ptr())
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns a pointer to the current item's value.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QJSValue* QList<QJSValue>::iterator::operator->() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a pointer to the current item's value.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#value">value</a>().</p></div>
        #[inline(always)]
        pub unsafe fn struct_deref(&self) -> ::cpp_core::Ptr<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__(
                    self as *const crate::q_list_of_q_j_s_value::Iterator,
                )
            };
            ::cpp_core::Ptr::from_raw(ffi_result)
        }

        /// <p>Makes the iterator go back by <i>j</i> items. (If <i>j</i> is negative, the iterator goes forward.)</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator& QList<QJSValue>::iterator::operator-=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--eq">C++ documentation</a> for <span style='color: green;'>```iterator &iterator::operator-=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Makes the iterator go back by <i>j</i> items. (If <i>j</i> is negative, the iterator goes forward.)</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-eq">operator+=</a>() and <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-">operator-</a>().</p></div>
        #[inline(always)]
        pub unsafe fn sub_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__15(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    /// <p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    ///
    /// C++ class: <span style='color: green;'>```QList<QJSValue>::const_iterator```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::const_iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or a <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;). If you want to modify the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as you iterate over it, use <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
    /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>const_iterator i;
    ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>constBegin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>constEnd(); <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
    ///
    /// </pre>
    /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
    /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>constBegin()<span class="operator">,</span> list<span class="operator">.</span>constEnd());
    ///
    /// </pre>
    /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
    #[repr(C)]
    pub struct ConstIterator {
        _unused: u8,
    }
    impl ConstIterator {
        /// <p>Advances the iterator by <i>j</i> items.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator& QList<QJSValue>::const_iterator::operator+=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-eq">C++ documentation</a> for <span style='color: green;'>```const_iterator &const_iterator::operator+=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Advances the iterator by <i>j</i> items.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--eq">operator-=</a>() and <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn add_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__10(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator& QList<QJSValue>::const_iterator::operator=(const QList<QJSValue>::const_iterator& other)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::const_iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or a <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;). If you want to modify the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as you iterate over it, use <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>const_iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>constBegin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>constEnd(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>constBegin()<span class="operator">,</span> list<span class="operator">.</span>constEnd());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        pub unsafe fn copy_from(
            &self,
            other: impl ::cpp_core::CastInto<
                ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
            >,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_6(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
                    >::cast_into(other)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator& QList<QJSValue>::const_iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#begin">QAssociativeIterable::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        pub unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__8(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::const_iterator::operator--(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator---1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix -- operator (<code>it--</code>) makes the preceding item current and returns an iterator to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn dec_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__9(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator& QList<QJSValue>::const_iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#end">QAssociativeIterable::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        pub unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__6(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::const_iterator::operator++(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix ++ operator (<code>it++</code>) advances the iterator to the next item in the container and returns an iterator to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn inc_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__7(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::const_iterator::operator[](long long j) const```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-5b-5d">C++ documentation</a> for <span style='color: green;'>```QJsonValue const_iterator::operator[](int j) const```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        /// <p>This function is provided to make <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> iterators behave like C++ pointers.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn index(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__1(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
                .expect("attempted to construct a null Ref")
        }

        /// <p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::const_iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p></div>
        #[inline(always)]
        pub unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
                .expect("attempted to construct a null Ref")
        }

        /// <p>Constructs an uninitialized iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::const_iterator::const_iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html#const_iterator">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an uninitialized iterator.</p>
        /// <p>Functions like operator*() and operator++() should not be called on an uninitialized iterator. Use operator=() to assign a value to it before using it.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>().</p></div>
        #[inline(always)]
        pub unsafe fn new_0a() -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result =
                { crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_const_iterator() };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::const_iterator::const_iterator(const QList<QJSValue>::iterator& o)```</span>.
        #[inline(always)]
        pub unsafe fn new_1a(
            o: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_const_iterator2(::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>::cast_into(o).as_raw_ptr())
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::const_iterator::const_iterator(const QList<QJSValue>::const_iterator& o)```</span>.
        #[inline(always)]
        pub unsafe fn new_copy(
            o: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_const_iterator1(
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
                    >::cast_into(o)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns a pointer to the current result.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QJSValue* QList<QJSValue>::const_iterator::operator->() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qfuture-const-iterator.html#operator--gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a pointer to the current result.</p></div>
        #[inline(always)]
        pub unsafe fn struct_deref(&self) -> ::cpp_core::Ptr<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                )
            };
            ::cpp_core::Ptr::from_raw(ffi_result as *mut crate::QJSValue)
        }

        /// <p>Makes the iterator go back by <i>j</i> items.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator& QList<QJSValue>::const_iterator::operator-=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--eq">C++ documentation</a> for <span style='color: green;'>```const_iterator &const_iterator::operator-=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Makes the iterator go back by <i>j</i> items.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-eq">operator+=</a>() and <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-">operator-</a>().</p></div>
        #[inline(always)]
        pub unsafe fn sub_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__11(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    /// C++ class: <span style='color: green;'>```QList<QJSValue>::MemoryLayout```</span>.
    #[repr(C)]
    pub struct MemoryLayout {
        _unused: u8,
    }
    impl MemoryLayout {
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::MemoryLayout& QList<QJSValue>::MemoryLayout::operator=(const QList<QJSValue>::MemoryLayout& other)```</span>.
        #[inline(always)]
        pub unsafe fn copy_from(
            &self,
            other: impl ::cpp_core::CastInto<
                ::cpp_core::Ref<crate::q_list_of_q_j_s_value::MemoryLayout>,
            >,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::MemoryLayout> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_MemoryLayout_operator_(
                    self as *const crate::q_list_of_q_j_s_value::MemoryLayout
                        as *mut crate::q_list_of_q_j_s_value::MemoryLayout,
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_j_s_value::MemoryLayout>,
                    >::cast_into(other)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::MemoryLayout::MemoryLayout()```</span>.
        #[inline(always)]
        pub unsafe fn new() -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::MemoryLayout> {
            let ffi_result =
                { crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_MemoryLayout_MemoryLayout() };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::MemoryLayout::MemoryLayout(const QList<QJSValue>::MemoryLayout& other)```</span>.
        #[inline(always)]
        pub unsafe fn new_copy(
            other: impl ::cpp_core::CastInto<
                ::cpp_core::Ref<crate::q_list_of_q_j_s_value::MemoryLayout>,
            >,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::MemoryLayout> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_MemoryLayout_MemoryLayout1(
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_j_s_value::MemoryLayout>,
                    >::cast_into(other)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }

    impl ::cpp_core::ops::Indirection for crate::q_list_of_q_j_s_value::Iterator {
        type Output = ::cpp_core::Ref<crate::QJSValue>;
        /// <p>Returns a modifiable reference to the current item's value.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a modifiable reference to the current item's value.</p>
        /// <p>Same as <a href="http://doc.qt.io/qt-5/qhash-iterator.html#value">value</a>().</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#key">key</a>().</p></div>
        #[inline(always)]
        unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_(
                    self as *const crate::q_list_of_q_j_s_value::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator==(const QList<QJSValue>::iterator& o) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-eq-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-not-eq">operator!=</a>().</p></div>
        #[inline(always)]
        fn eq(&self, o: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>) -> bool {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__2(
                    self as *const crate::q_list_of_q_j_s_value::Iterator,
                    o.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator<(const QList<QJSValue>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn lt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_1(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator<=(const QList<QJSValue>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn le(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__4(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator>(const QList<QJSValue>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn gt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_2(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator>=(const QList<QJSValue>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn ge(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__5(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator==(const QList<QJSValue>::const_iterator& o) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-eq-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-not-eq">operator!=</a>().</p></div>
        #[inline(always)]
        fn eq(&self, o: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>) -> bool {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__6(
                    self as *const crate::q_list_of_q_j_s_value::Iterator,
                    o.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator<(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn lt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_3(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator<=(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn le(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__8(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator>(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn gt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_4(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::iterator::operator>=(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn ge(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__9(
                self as *const crate::q_list_of_q_j_s_value::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::ops::Increment for crate::q_list_of_q_j_s_value::Iterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>;
        /// <p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator& QList<QJSValue>::iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#end">QHash::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__10(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::cpp_core::ops::Decrement for crate::q_list_of_q_j_s_value::Iterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>;
        /// <p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator& QList<QJSValue>::iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#begin">QHash::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator__12(
                    self as *const crate::q_list_of_q_j_s_value::Iterator
                        as *mut crate::q_list_of_q_j_s_value::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::std::ops::Add<::std::os::raw::c_longlong> for &crate::q_list_of_q_j_s_value::Iterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::iterator::operator+(long long j) const```</span>.
        #[inline(always)]
        fn add(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_5(
                        self as *const crate::q_list_of_q_j_s_value::Iterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::std::os::raw::c_longlong> for &crate::q_list_of_q_j_s_value::Iterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::iterator::operator-(long long j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_6(
                        self as *const crate::q_list_of_q_j_s_value::Iterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>
        for &crate::q_list_of_q_j_s_value::Iterator
    {
        type Output = ::std::os::raw::c_int;
        /// Calls C++ function: <span style='color: green;'>```int QList<QJSValue>::iterator::operator-(QList<QJSValue>::iterator j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>,
        ) -> ::std::os::raw::c_int {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_operator_7(
                    self as *const crate::q_list_of_q_j_s_value::Iterator,
                    j.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::ops::Indirection for crate::q_list_of_q_j_s_value::ConstIterator {
        type Output = ::cpp_core::Ref<crate::QJSValue>;
        /// <p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::const_iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p></div>
        #[inline(always)]
        unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QJSValue> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
                .expect("attempted to construct a null Ref")
        }
    }

    impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::ConstIterator
    {
        /// <p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::const_iterator::operator==(const QList<QJSValue>::const_iterator& o) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-eq-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-not-eq">operator!=</a>().</p></div>
        #[inline(always)]
        fn eq(&self, o: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>) -> bool {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__2(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                    o.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::const_iterator::operator<(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-lt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn lt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_1(
                self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::const_iterator::operator<=(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-lt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn le(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__4(
                self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::const_iterator::operator>(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn gt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_2(
                self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for crate::q_list_of_q_j_s_value::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::const_iterator::operator>=(const QList<QJSValue>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-gt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn ge(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__5(
                self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::ops::Increment for crate::q_list_of_q_j_s_value::ConstIterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>;
        /// <p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator& QList<QJSValue>::const_iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#end">QAssociativeIterable::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__6(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::cpp_core::ops::Decrement for crate::q_list_of_q_j_s_value::ConstIterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>;
        /// <p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator& QList<QJSValue>::const_iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#begin">QAssociativeIterable::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator__8(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator
                        as *mut crate::q_list_of_q_j_s_value::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::std::ops::Add<::std::os::raw::c_longlong> for &crate::q_list_of_q_j_s_value::ConstIterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::const_iterator::operator+(long long j) const```</span>.
        #[inline(always)]
        fn add(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_3(
                        self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::std::os::raw::c_longlong> for &crate::q_list_of_q_j_s_value::ConstIterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::const_iterator::operator-(long long j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_4(
                        self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>>
        for &crate::q_list_of_q_j_s_value::ConstIterator
    {
        type Output = ::std::os::raw::c_int;
        /// Calls C++ function: <span style='color: green;'>```int QList<QJSValue>::const_iterator::operator-(QList<QJSValue>::const_iterator j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::cpp_core::Ref<crate::q_list_of_q_j_s_value::ConstIterator>,
        ) -> ::std::os::raw::c_int {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_operator_5(
                    self as *const crate::q_list_of_q_j_s_value::ConstIterator,
                    j.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::CppDeletable for crate::q_list_of_q_j_s_value::Iterator {
        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QJSValue>::iterator::~iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> features both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;) and to modify the list item associated with the iterator. If you want to iterate over a const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>, use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Let's see a few examples of things we can do with a <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> that we cannot do with a <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a>. Here's an example that increments every value stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;int&gt; by 2:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     <span class="operator">*</span>i <span class="operator">+</span><span class="operator">=</span> <span class="number">2</span>;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>begin()<span class="operator">,</span> list<span class="operator">.</span>end());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        unsafe fn delete(&self) {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_iterator_diterator(
                self as *const crate::q_list_of_q_j_s_value::Iterator
                    as *mut crate::q_list_of_q_j_s_value::Iterator,
            )
        }
    }

    impl ::cpp_core::CppDeletable for crate::q_list_of_q_j_s_value::ConstIterator {
        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QJSValue>::const_iterator::~const_iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::const_iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or a <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;). If you want to modify the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as you iterate over it, use <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>const_iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>constBegin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>constEnd(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>constBegin()<span class="operator">,</span> list<span class="operator">.</span>constEnd());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        unsafe fn delete(&self) {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_const_iterator_dconst_iterator(
                self as *const crate::q_list_of_q_j_s_value::ConstIterator
                    as *mut crate::q_list_of_q_j_s_value::ConstIterator,
            )
        }
    }

    impl ::cpp_core::CppDeletable for crate::q_list_of_q_j_s_value::MemoryLayout {
        /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QJSValue>::MemoryLayout::~MemoryLayout()```</span>.
        #[inline(always)]
        unsafe fn delete(&self) {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_MemoryLayout_dMemoryLayout(
                self as *const crate::q_list_of_q_j_s_value::MemoryLayout
                    as *mut crate::q_list_of_q_j_s_value::MemoryLayout,
            )
        }
    }
}
/// <p>The <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> class is a template class that provides lists.</p>
///
/// C++ class: <span style='color: green;'>```QList<QJSValue>```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qlist.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> class is a template class that provides lists.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; is one of Qt's generic <a href="http://doc.qt.io/qt-5/containers.html">container classes</a>. It stores items in a list that provides fast index-based access and index-based insertions and removals.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;, <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a>&lt;T&gt;, and <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; provide similar APIs and functionality. They are often interchangeable, but there are performance consequences. Here is an overview of use cases:</p>
/// <ul>
/// <li><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> should be your default first choice. <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; will usually give better performance than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;, because <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; always stores its items sequentially in memory, where <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; will allocate its items on the heap unless <code>sizeof(T) &lt;= sizeof(void*)</code> and T has been declared to be either a <code>Q_MOVABLE_TYPE</code> or a <code>Q_PRIMITIVE_TYPE</code> using <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_DECLARE_TYPEINFO">Q_DECLARE_TYPEINFO</a>. See the <a href="http://marcmutz.wordpress.com/effective-qt/containers/#containers-qlist">Pros and Cons of Using QList</a> for an explanation.</li>
/// <li>However, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is used throughout the Qt APIs for passing parameters and for returning values. Use <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> to interface with those APIs.</li>
/// <li>If you need a real linked list, which guarantees <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a> insertions mid-list and uses iterators to items rather than indexes, use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a>.</li>
/// </ul>
/// <p><b>Note: </b><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> and <a href="http://doc.qt.io/qt-5/qvarlengtharray.html">QVarLengthArray</a> both guarantee C-compatible array layout. <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> does not. This might be important if your application must interface with a C API.</p><p><b>Note: </b>Iterators into a <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> and references into heap-allocating QLists remain valid as long as the referenced items remain in the container. This is not true for iterators and references into a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> and non-heap-allocating QLists.</p><p>Internally, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; is represented as an array of T if <code>sizeof(T) &lt;= sizeof(void*)</code> and T has been declared to be either a <code>Q_MOVABLE_TYPE</code> or a <code>Q_PRIMITIVE_TYPE</code> using <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_DECLARE_TYPEINFO">Q_DECLARE_TYPEINFO</a>. Otherwise, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; is represented as an array of T* and the items are allocated on the heap.</p>
/// <p>The array representation allows very fast insertions and index-based access. The <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>() operations are also very fast because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates memory at both ends of its internal array. (See <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">Algorithmic Complexity</a> for details.</p>
/// <p>Note, however, that when the conditions specified above are not met, each append or insert of a new item requires allocating the new item on the heap, and this per item allocation will make <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> a better choice for use cases that do a lot of appending or inserting, because <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> can allocate memory for many items in a single heap allocation.</p>
/// <p>Note that the internal array only ever gets bigger over the life of the list. It never shrinks. The internal array is deallocated by the destructor and by the assignment operator, when one list is assigned to another.</p>
/// <p>Here's an example of a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> that stores integers and a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> that stores <a href="http://doc.qt.io/qt-5/qdate.html">QDate</a> values:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span> integerList;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qdate.html">QDate</a></span><span class="operator">&gt;</span> dateList;
///
/// </pre>
/// <p>Qt includes a <a href="http://doc.qt.io/qt-5/qstringlist.html">QStringList</a> class that inherits <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qstring.html">QString</a>&gt; and adds a few convenience functions, such as <a href="http://doc.qt.io/qt-5/qstringlist.html#join">QStringList::join</a>() and <a href="http://doc.qt.io/qt-5/qstringlist.html#filter">QStringList::filter</a>(). <a href="http://doc.qt.io/qt-5/qstring.html#split">QString::split</a>() creates QStringLists from strings.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> stores a list of items. The default constructor creates an empty list. To insert items into the list, you can use operator&lt;&lt;():</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"one"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"two"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"three"</span>;
///   <span class="comment">// list: ["one", "two", "three"]</span>
///
/// </pre>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides these basic functions to add, move, and remove items: <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#replace">replace</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#move">move</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#swap">swap</a>(). In addition, it provides the following convenience functions: <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>().</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> uses 0-based indexes, just like C++ arrays. To access the item at a particular index position, you can use operator[](). On non-const lists, operator[]() returns a reference to the item and can be used on the left side of an assignment:</p>
/// <pre class="cpp">
///
///   <span class="keyword">if</span> (list<span class="operator">[</span><span class="number">0</span><span class="operator">]</span> <span class="operator">=</span><span class="operator">=</span> <span class="string">"Bob"</span>)
/// &#32;     list<span class="operator">[</span><span class="number">0</span><span class="operator">]</span> <span class="operator">=</span> <span class="string">"Robert"</span>;
///
/// </pre>
/// <p>Because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is implemented as an array of pointers for types that are larger than a pointer or are not movable, this operation requires (<a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>). For read-only access, an alternative syntax is to use <a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>():</p>
/// <pre class="cpp">
///
///   <span class="keyword">for</span> (<span class="type">int</span> i <span class="operator">=</span> <span class="number">0</span>; i <span class="operator">&lt;</span> list<span class="operator">.</span>size(); <span class="operator">+</span><span class="operator">+</span>i) {
/// &#32;     <span class="keyword">if</span> (list<span class="operator">.</span>at(i) <span class="operator">=</span><span class="operator">=</span> <span class="string">"Jane"</span>)
/// &#32;   &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"Found Jane at position "</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
///   }
///
/// </pre>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() can be faster than operator[](), because it never causes a <a href="http://doc.qt.io/qt-5/implicit-sharing.html#deep-copy">deep copy</a> to occur.</p>
/// <p>A common requirement is to remove an item from a list and do something with it. For this, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>(). Here's a loop that removes the items from a list one at a time and calls <code>delete</code> on them:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
///   <span class="keyword">while</span> (<span class="operator">!</span>list<span class="operator">.</span>isEmpty())
/// &#32;     <span class="keyword">delete</span> list<span class="operator">.</span>takeFirst();
///
/// </pre>
/// <p>Inserting and removing items at either end of the list is very fast (<a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a> in most cases), because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates extra space on both sides of its internal buffer to allow for fast growth at both ends of the list.</p>
/// <p>If you want to find all occurrences of a particular value in a list, use <a href="http://doc.qt.io/qt-5/qlist.html#indexOf">indexOf</a>() or <a href="http://doc.qt.io/qt-5/qlist.html#lastIndexOf">lastIndexOf</a>(). The former searches forward starting from a given index position, the latter searches backward. Both return the index of a matching item if they find it; otherwise, they return -1. For example:</p>
/// <pre class="cpp">
///
///   <span class="type">int</span> i <span class="operator">=</span> list<span class="operator">.</span>indexOf(<span class="string">"Jane"</span>);
///   <span class="keyword">if</span> (i <span class="operator">!</span><span class="operator">=</span> <span class="operator">-</span><span class="number">1</span>)
/// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"First occurrence of Jane is at position "</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
///
/// </pre>
/// <p>If you simply want to check whether a list contains a particular value, use <a href="http://doc.qt.io/qt-5/qlist.html#contains">contains</a>(). If you want to find out how many times a particular value occurs in the list, use <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>(). If you want to replace all occurrences of a particular value with another, use <a href="http://doc.qt.io/qt-5/qlist.html#replace">replace</a>().</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>'s value type must be an <a href="http://doc.qt.io/qt-5/containers.html#assignable-data-type">assignable data type</a>. This covers most data types that are commonly used, but the compiler won't let you, for example, store a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> as a value; instead, store a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *. A few functions have additional requirements; for example, <a href="http://doc.qt.io/qt-5/qlist.html#indexOf">indexOf</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#lastIndexOf">lastIndexOf</a>() expect the value type to support <code>operator==()</code>. These requirements are documented on a per-function basis.</p>
/// <p>Like the other container classes, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a> (<a href="http://doc.qt.io/qt-5/qlistiterator.html">QListIterator</a> and <a href="http://doc.qt.io/qt-5/qmutablelistiterator.html">QMutableListIterator</a>) and <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> (<a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> and <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a>). In practice, these are rarely used, because you can use indexes into the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is implemented in such a way that direct index-based access is just as fast as using iterators.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> does <i>not</i> support inserting, prepending, appending or replacing with references to its own values. Doing so will cause your application to abort with an error message.</p>
/// <p>To make <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as efficient as possible, its member functions don't validate their input before using it. Except for <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>(), member functions always assume the list is <i>not</i> empty. Member functions that take index values as parameters always assume their index value parameters are in the valid range. This means <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> member functions can fail. If you define QT_NO_DEBUG when you compile, failures will not be detected. If you <i>don't</i> define QT_NO_DEBUG, failures will be detected using <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_ASSERT">Q_ASSERT</a>() or <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_ASSERT_X">Q_ASSERT_X</a>() with an appropriate message.</p>
/// <p>To avoid failures when your list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling other member functions. If you must pass an index value that might not be in the valid range, check that it is less than the value returned by <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() but <i>not</i> less than 0.</p>
/// <a name="more-members"></a></div>
#[repr(C)]
pub struct QListOfQJSValue {
    _unused: u8,
}
impl QListOfQJSValue {
    /// <p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>& QList<QJSValue>::operator+=(const QList<QJSValue>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-2b">operator+</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>().</p></div>
    #[inline(always)]
    pub unsafe fn add_assign_q_list_of_q_j_s_value(
        &self,
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) -> ::cpp_core::Ref<crate::QListOfQJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator__4(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(l)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>& QList<QJSValue>::operator+=(const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends <i>value</i> to the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">operator&lt;&lt;</a>().</p></div>
    #[inline(always)]
    pub unsafe fn add_assign_q_j_s_value(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::Ref<crate::QListOfQJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator__5(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Inserts <i>value</i> at the end of the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::append(const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#append">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at the end of the list.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>append(<span class="string">"one"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"two"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"three"</span>);
    ///   <span class="comment">// list: ["one", "two", "three"]</span>
    ///
    /// </pre>
    /// <p>This is the same as list.insert(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(), <i>value</i>).</p>
    /// <p>If this list is not shared, this operation is typically very fast (amortized <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>), because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates extra space on both sides of its internal buffer to allow for fast growth at both ends of the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">operator&lt;&lt;</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>().</p></div>
    #[inline(always)]
    pub unsafe fn append_q_j_s_value(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_append(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::append(const QList<QJSValue>& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#append-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends the items of the <i>value</i> list to this list.</p>
    /// <p>This function was introduced in  Qt 4.5.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">operator&lt;&lt;</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">operator+=</a>().</p></div>
    #[inline(always)]
    pub unsafe fn append_q_list_of_q_j_s_value(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_append1(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(t)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns the item at index position <i>i</i> in the list. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::at(int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#at">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at index position <i>i</i> in the list. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p>This function is very fast (<a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#value">value</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    pub unsafe fn at(&self, i: ::std::os::raw::c_int) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_at(self as *const crate::QListOfQJSValue, i)
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::back()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn back_mut(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_back(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::back() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#back-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn back(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_back1(self as *const crate::QListOfQJSValue)
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::begin()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    pub unsafe fn begin_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_begin(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::begin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn begin(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_begin1(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::cbegin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#cbegin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p>This function was introduced in  Qt 5.0.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#cend">cend</a>().</p></div>
    #[inline(always)]
    pub unsafe fn cbegin(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_cbegin(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::cend() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#cend">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p>This function was introduced in  Qt 5.0.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#cbegin">cbegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    pub unsafe fn cend(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_cend(self as *const crate::QListOfQJSValue)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes all items from the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::clear()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#clear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes all items from the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAll">removeAll</a>().</p></div>
    #[inline(always)]
    pub unsafe fn clear(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_clear(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::constBegin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">constEnd</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_begin(
        &self,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_constBegin(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::constEnd() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_end(
        &self,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_constEnd(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::constFirst() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constLast">constLast</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_first(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_constFirst(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::constLast() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constFirst">constFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_last(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_constLast(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Assigns <i>other</i> to this list and returns a reference to this list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>& QList<QJSValue>::operator=(const QList<QJSValue>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns <i>other</i> to this list and returns a reference to this list.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) -> ::cpp_core::Ref<crate::QListOfQJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator_(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(l)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns the number of items in the list. This is effectively the same as <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QJSValue>::count() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#count-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the list. This is effectively the same as <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p></div>
    #[inline(always)]
    pub unsafe fn count(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_count1(self as *const crate::QListOfQJSValue)
    }

    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::detach()```</span>.
    #[inline(always)]
    pub unsafe fn detach(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_detach(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::detachShared()```</span>.
    #[inline(always)]
    pub unsafe fn detach_shared(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_detachShared(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and returns <code>true</code> if the list is empty.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::empty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#empty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and returns <code>true</code> if the list is empty.</p></div>
    #[inline(always)]
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_empty(self as *const crate::QListOfQJSValue)
    }

    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::end()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">constEnd</a>().</p></div>
    #[inline(always)]
    pub unsafe fn end_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_end(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::end() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn end(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_end1(self as *const crate::QListOfQJSValue)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the item associated with the iterator <i>pos</i> from the list, and returns an iterator to the next item in the list (which may be <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::erase(QList<QJSValue>::iterator pos)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#erase">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the item associated with the iterator <i>pos</i> from the list, and returns an iterator to the next item in the list (which may be <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn erase_1a(
        &self,
        pos: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_erase(self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>::cast_into(pos).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::erase(QList<QJSValue>::iterator first, QList<QJSValue>::iterator last)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#erase-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Removes all the items from <i>begin</i> up to (but not including) <i>end</i>. Returns an iterator to the same item that <i>end</i> referred to before the call.</p></div>
    #[inline(always)]
    pub unsafe fn erase_2a(
        &self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_erase1(self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>::cast_into(last).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::first()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#first">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constFirst">constFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn first_mut(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_first(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::first() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#first-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn first(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_first1(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::front()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn front_mut(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_front(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::front() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#front-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn front(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_front1(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::operator[](int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Same as <a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>(). This function runs in <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>.</p></div>
    #[inline(always)]
    pub unsafe fn index(&self, i: ::std::os::raw::c_int) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator__2(
                self as *const crate::QListOfQJSValue,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns the item at index position <i>i</i> as a modifiable reference. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::operator[](int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at index position <i>i</i> as a modifiable reference. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p>If this function is called on a list that is currently being shared, it will trigger a copy of all elements. Otherwise, this function runs in <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>. If you do not want to modify the list you should use <a href="http://doc.qt.io/qt-5/qlist.html#at">QList::at</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#value">value</a>().</p></div>
    #[inline(always)]
    pub unsafe fn index_mut(&self, i: ::std::os::raw::c_int) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator__3(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Inserts <i>value</i> at index position <i>i</i> in the list. If <i>i</i> &lt;= 0, the value is prepended to the list. If <i>i</i> &gt;= <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(), the value is appended to the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::insert(int i, const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#insert">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at index position <i>i</i> in the list. If <i>i</i> &lt;= 0, the value is prepended to the list. If <i>i</i> &gt;= <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(), the value is appended to the list.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"alpha"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"beta"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"delta"</span>;
    ///   list<span class="operator">.</span>insert(<span class="number">2</span><span class="operator">,</span> <span class="string">"gamma"</span>);
    ///   <span class="comment">// list: ["alpha", "beta", "gamma", "delta"]</span>
    ///
    /// </pre>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#replace">replace</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn insert_int_q_j_s_value(
        &self,
        i: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_insert(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            i,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::insert(QList<QJSValue>::iterator before, const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#insert-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Inserts <i>value</i> in front of the item pointed to by the iterator <i>before</i>. Returns an iterator pointing at the inserted item. Note that the iterator passed to the function will be invalid after the call; the returned iterator should be used instead.</p></div>
    #[inline(always)]
    pub unsafe fn insert_iterator_q_j_s_value(
        &self,
        before: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_insert1(self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_j_s_value::Iterator>>::cast_into(before).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::isDetached() const```</span>.
    #[inline(always)]
    pub unsafe fn is_detached(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_isDetached(
            self as *const crate::QListOfQJSValue,
        )
    }

    /// <p>Returns <code>true</code> if the list contains no items; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::isEmpty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the list contains no items; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_isEmpty(self as *const crate::QListOfQJSValue)
    }

    /// Calls C++ function: <span style='color: green;'>```bool QList<QJSValue>::isSharedWith(const QList<QJSValue>& other) const```</span>.
    #[inline(always)]
    pub unsafe fn is_shared_with(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_isSharedWith(
            self as *const crate::QListOfQJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(other)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue& QList<QJSValue>::last()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#last">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constLast">constLast</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn last_mut(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_last(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QJSValue& QList<QJSValue>::last() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#last-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn last(&self) -> ::cpp_core::Ref<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_last1(self as *const crate::QListOfQJSValue)
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QJSValue)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is identical to <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QJSValue>::length() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#length">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is identical to <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p>
    /// <p>This function was introduced in  Qt 4.5.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p></div>
    #[inline(always)]
    pub unsafe fn length(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_length(self as *const crate::QListOfQJSValue)
    }

    /// <p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue> QList<QJSValue>::mid(int pos, int length = …) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#mid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p></div>
    #[inline(always)]
    pub unsafe fn mid_2a(
        &self,
        pos: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QListOfQJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_mid(
                self as *const crate::QListOfQJSValue,
                pos,
                length,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue> QList<QJSValue>::mid(int pos) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#mid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p></div>
    #[inline(always)]
    pub unsafe fn mid_1a(
        &self,
        pos: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QListOfQJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_mid1(
                self as *const crate::QListOfQJSValue,
                pos,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Moves the item at index position <i>from</i> to index position <i>to</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::move(int from, int to)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#move">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Moves the item at index position <i>from</i> to index position <i>to</i>.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"A"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"B"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"C"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"D"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"E"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"F"</span>;
    ///   list<span class="operator">.</span>move(<span class="number">1</span><span class="operator">,</span> <span class="number">4</span>);
    ///   <span class="comment">// list: ["A", "C", "D", "E", "B", "F"]</span>
    ///
    /// </pre>
    /// <p>This is the same as insert(<i>to</i>, <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(<i>from</i>)).This function assumes that both <i>from</i> and <i>to</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>from</i> and <i>to</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#swap">swap</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn move_(&self, from: ::std::os::raw::c_int, to: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_move(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            from,
            to,
        )
    }

    /// <p>Constructs an empty list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::QList()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#QList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an empty list.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QListOfQJSValue> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_QList() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a copy of <i>other</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QJSValue>::QList(const QList<QJSValue>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#QList-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a copy of <i>other</i>.</p>
    /// <p>This operation takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>, because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is <a href="http://doc.qt.io/qt-5/implicit-sharing.html">implicitly shared</a>. This makes returning a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), and that takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">linear time</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-eq">operator=</a>().</p></div>
    #[inline(always)]
    pub unsafe fn new_copy(
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QListOfQJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_QList1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(l)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::pop_back()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#pop_back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn pop_back(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_pop_back(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::pop_front()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#pop_front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn pop_front(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_pop_front(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }

    /// <p>Inserts <i>value</i> at the beginning of the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::prepend(const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#prepend">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at the beginning of the list.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>prepend(<span class="string">"one"</span>);
    ///   list<span class="operator">.</span>prepend(<span class="string">"two"</span>);
    ///   list<span class="operator">.</span>prepend(<span class="string">"three"</span>);
    ///   <span class="comment">// list: ["three", "two", "one"]</span>
    ///
    /// </pre>
    /// <p>This is the same as list.insert(0, <i>value</i>).</p>
    /// <p>If this list is not shared, this operation is typically very fast (amortized <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>), because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates extra space on both sides of its internal buffer to allow for fast growth at both ends of the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>().</p></div>
    #[inline(always)]
    pub unsafe fn prepend(&self, t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_prepend(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(<i>value</i>).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::push_back(const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#push_back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(<i>value</i>).</p></div>
    #[inline(always)]
    pub unsafe fn push_back(&self, t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_push_back(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(<i>value</i>).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::push_front(const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#push_front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(<i>value</i>).</p></div>
    #[inline(always)]
    pub unsafe fn push_front(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_push_front(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>Removes the item at index position <i>i</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::removeAt(int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the item at index position <i>i</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeOne">removeOne</a>().</p></div>
    #[inline(always)]
    pub unsafe fn remove_at(&self, i: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_removeAt(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            i,
        )
    }

    /// <p>Removes the first item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(0). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::removeFirst()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the first item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(0). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>().</p></div>
    #[inline(always)]
    pub unsafe fn remove_first(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_removeFirst(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }

    /// <p>Removes the last item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::removeLast()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the last item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>().</p></div>
    #[inline(always)]
    pub unsafe fn remove_last(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_removeLast(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }

    /// <p>Replaces the item at index position <i>i</i> with <i>value</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::replace(int i, const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#replace">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Replaces the item at index position <i>i</i> with <i>value</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">operator[]</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn replace(
        &self,
        i: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_replace(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            i,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>Reserve space for <i>alloc</i> elements.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::reserve(int size)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#reserve">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Reserve space for <i>alloc</i> elements.</p>
    /// <p>If <i>alloc</i> is smaller than the current size of the list, nothing will happen.</p>
    /// <p>Use this function to avoid repetetive reallocation of <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>'s internal data if you can predict how many elements will be appended. Note that the reservation applies only to the internal pointer array.</p>
    /// <p>This function was introduced in  Qt 4.7.</p></div>
    #[inline(always)]
    pub unsafe fn reserve(&self, size: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_reserve(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::setSharable(bool sharable)```</span>.
    #[inline(always)]
    pub unsafe fn set_sharable(&self, sharable: bool) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_setSharable(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            sharable,
        )
    }

    /// <p>Returns the number of items in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QJSValue>::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p></div>
    #[inline(always)]
    pub unsafe fn size(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_size(self as *const crate::QListOfQJSValue)
    }

    /// <p>Swaps list <i>other</i> with this list. This operation is very fast and never fails.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::swap(QList<QJSValue>& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#swap">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Swaps list <i>other</i> with this list. This operation is very fast and never fails.</p>
    /// <p>This function was introduced in  Qt 4.8.</p></div>
    #[inline(always)]
    pub unsafe fn swap_1a(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQJSValue>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_swap(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQJSValue>>::cast_into(other)
                .as_raw_ptr() as *mut crate::QListOfQJSValue,
        )
    }

    /// <p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::swap(int i, int j)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#swap-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"A"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"B"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"C"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"D"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"E"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"F"</span>;
    ///   list<span class="operator">.</span>swap(<span class="number">1</span><span class="operator">,</span> <span class="number">4</span>);
    ///   <span class="comment">// list: ["A", "E", "C", "D", "B", "F"]</span>
    ///
    /// </pre>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#move">move</a>().</p></div>
    #[inline(always)]
    pub unsafe fn swap_2a(&self, i: ::std::os::raw::c_int, j: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_swap1(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            i,
            j,
        )
    }

    /// <p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QJSValue>::swapItemsAt(int i, int j)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#swapItemsAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"A"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"B"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"C"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"D"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"E"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"F"</span>;
    ///   list<span class="operator">.</span>swapItemsAt(<span class="number">1</span><span class="operator">,</span> <span class="number">4</span>);
    ///   <span class="comment">// list: ["A", "E", "C", "D", "B", "F"]</span>
    ///
    /// </pre>
    /// <p>This function was introduced in  Qt 5.13.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#move">move</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0")))
    )]
    #[cfg(any(
        any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0"),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn swap_items_at(&self, i: ::std::os::raw::c_int, j: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_swapItemsAt(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            i,
            j,
        )
    }

    /// <p>Removes the item at index position <i>i</i> and returns it. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QList<QJSValue>::takeAt(int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the item at index position <i>i</i> and returns it. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p>If you don't use the return value, <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>() is more efficient.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>().</p></div>
    #[inline(always)]
    pub unsafe fn take_at(&self, i: ::std::os::raw::c_int) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_takeAt(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
                i,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the first item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(0). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QList<QJSValue>::takeFirst()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the first item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(0). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>If this list is not shared, this operation takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>.</p>
    /// <p>If you don't use the return value, <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>() is more efficient.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>().</p></div>
    #[inline(always)]
    pub unsafe fn take_first(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_takeFirst(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the last item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QList<QJSValue>::takeLast()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the last item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>If this list is not shared, this operation takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>.</p>
    /// <p>If you don't use the return value, <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>() is more efficient.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>().</p></div>
    #[inline(always)]
    pub unsafe fn take_last(&self) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_takeLast(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the value at index position <i>i</i> in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QList<QJSValue>::value(int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#value">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value at index position <i>i</i> in the list.</p>
    /// <p>If the index <i>i</i> is out of bounds, the function returns a <a href="http://doc.qt.io/qt-5/containers.html#default-constructed-value">default-constructed value</a>. If you are certain that the index is going to be within bounds, you can use <a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() instead, which is slightly faster.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    pub unsafe fn value_1a(&self, i: ::std::os::raw::c_int) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_value(
                self as *const crate::QListOfQJSValue,
                i,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QJSValue QList<QJSValue>::value(int i, const QJSValue& defaultValue) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#value-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>If the index <i>i</i> is out of bounds, the function returns <i>defaultValue</i>.</p></div>
    #[inline(always)]
    pub unsafe fn value_2a(
        &self,
        i: ::std::os::raw::c_int,
        default_value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    ) -> ::cpp_core::CppBox<crate::QJSValue> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_value1(
                self as *const crate::QListOfQJSValue,
                i,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(default_value)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

pub mod q_list_of_q_qml_error {
    //! C++ type: <span style='color: green;'>```QList<QQmlError>```</span>

    /// <p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    ///
    /// C++ class: <span style='color: green;'>```QList<QQmlError>::iterator```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> features both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;) and to modify the list item associated with the iterator. If you want to iterate over a const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>, use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
    /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
    ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
    ///
    /// </pre>
    /// <p>Let's see a few examples of things we can do with a <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> that we cannot do with a <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a>. Here's an example that increments every value stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;int&gt; by 2:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
    ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     <span class="operator">*</span>i <span class="operator">+</span><span class="operator">=</span> <span class="number">2</span>;
    ///
    /// </pre>
    /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
    /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>begin()<span class="operator">,</span> list<span class="operator">.</span>end());
    ///
    /// </pre>
    /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
    #[repr(C)]
    pub struct Iterator {
        _unused: u8,
    }
    impl Iterator {
        /// <p>Advances the iterator by <i>j</i> items. (If <i>j</i> is negative, the iterator goes backward.)</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator& QList<QQmlError>::iterator::operator+=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-eq">C++ documentation</a> for <span style='color: green;'>```iterator &iterator::operator+=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Advances the iterator by <i>j</i> items. (If <i>j</i> is negative, the iterator goes backward.)</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--eq">operator-=</a>() and <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn add_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__14(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator& QList<QQmlError>::iterator::operator=(const QList<QQmlError>::iterator& other)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> features both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;) and to modify the list item associated with the iterator. If you want to iterate over a const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>, use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Let's see a few examples of things we can do with a <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> that we cannot do with a <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a>. Here's an example that increments every value stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;int&gt; by 2:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     <span class="operator">*</span>i <span class="operator">+</span><span class="operator">=</span> <span class="number">2</span>;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>begin()<span class="operator">,</span> list<span class="operator">.</span>end());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        pub unsafe fn copy_from(
            &self,
            other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_8(self as *const crate::q_list_of_q_qml_error::Iterator as *mut crate::q_list_of_q_qml_error::Iterator, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>::cast_into(other).as_raw_ptr())
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator& QList<QQmlError>::iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#begin">QHash::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        pub unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__12(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::iterator::operator--(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator---1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix -- operator (<code>i--</code>) makes the preceding item current and returns an iterator pointing to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn dec_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__13(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator& QList<QQmlError>::iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#end">QHash::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        pub unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__10(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::iterator::operator++(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix ++ operator (<code>i++</code>) advances the iterator to the next item in the hash and returns an iterator to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn inc_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__11(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns a modifiable reference to the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::iterator::operator[](long long j) const```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-5b-5d">C++ documentation</a> for <span style='color: green;'>```QJsonValueRef iterator::operator[](int j) const```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a modifiable reference to the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        /// <p>This function is provided to make <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> iterators behave like C++ pointers.</p>
        /// <p>The return value is of type <a href="http://doc.qt.io/qt-5/qjsonvalue.html#qjsonvalueref">QJsonValueRef</a>, a helper class for <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> and <a href="http://doc.qt.io/qt-5/qjsonobject.html">QJsonObject</a>. When you get an object of type <a href="http://doc.qt.io/qt-5/qjsonvalue.html#qjsonvalueref">QJsonValueRef</a>, you can use it as if it were a reference to a <a href="http://doc.qt.io/qt-5/qjsonvalue.html">QJsonValue</a>. If you assign to it, the assignment will apply to the character in the <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> of <a href="http://doc.qt.io/qt-5/qjsonobject.html">QJsonObject</a> from which you got the reference.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn index(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__1(
                    self as *const crate::q_list_of_q_qml_error::Iterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>Returns a modifiable reference to the current item's value.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a modifiable reference to the current item's value.</p>
        /// <p>Same as <a href="http://doc.qt.io/qt-5/qhash-iterator.html#value">value</a>().</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#key">key</a>().</p></div>
        #[inline(always)]
        pub unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_(
                    self as *const crate::q_list_of_q_qml_error::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>Constructs an uninitialized iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::iterator::iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html#iterator">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an uninitialized iterator.</p>
        /// <p>Functions like operator*() and operator++() should not be called on an uninitialized iterator. Use operator=() to assign a value to it before using it.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>().</p></div>
        #[inline(always)]
        pub unsafe fn new() -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_iterator() };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::iterator::iterator(const QList<QQmlError>::iterator& o)```</span>.
        #[inline(always)]
        pub unsafe fn new_copy(
            o: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_iterator1(::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>::cast_into(o).as_raw_ptr())
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns a pointer to the current item's value.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QQmlError* QList<QQmlError>::iterator::operator->() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a pointer to the current item's value.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#value">value</a>().</p></div>
        #[inline(always)]
        pub unsafe fn struct_deref(&self) -> ::cpp_core::Ptr<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__(
                    self as *const crate::q_list_of_q_qml_error::Iterator,
                )
            };
            ::cpp_core::Ptr::from_raw(ffi_result)
        }

        /// <p>Makes the iterator go back by <i>j</i> items. (If <i>j</i> is negative, the iterator goes forward.)</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator& QList<QQmlError>::iterator::operator-=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--eq">C++ documentation</a> for <span style='color: green;'>```iterator &iterator::operator-=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Makes the iterator go back by <i>j</i> items. (If <i>j</i> is negative, the iterator goes forward.)</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-eq">operator+=</a>() and <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-">operator-</a>().</p></div>
        #[inline(always)]
        pub unsafe fn sub_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__15(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    /// <p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    ///
    /// C++ class: <span style='color: green;'>```QList<QQmlError>::const_iterator```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
    /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::const_iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or a <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;). If you want to modify the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as you iterate over it, use <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
    /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>const_iterator i;
    ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>constBegin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>constEnd(); <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
    ///
    /// </pre>
    /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
    /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
    ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
    ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>constBegin()<span class="operator">,</span> list<span class="operator">.</span>constEnd());
    ///
    /// </pre>
    /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
    #[repr(C)]
    pub struct ConstIterator {
        _unused: u8,
    }
    impl ConstIterator {
        /// <p>Advances the iterator by <i>j</i> items.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator& QList<QQmlError>::const_iterator::operator+=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-eq">C++ documentation</a> for <span style='color: green;'>```const_iterator &const_iterator::operator+=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Advances the iterator by <i>j</i> items.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--eq">operator-=</a>() and <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn add_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__10(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator& QList<QQmlError>::const_iterator::operator=(const QList<QQmlError>::const_iterator& other)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::const_iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or a <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;). If you want to modify the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as you iterate over it, use <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>const_iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>constBegin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>constEnd(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>constBegin()<span class="operator">,</span> list<span class="operator">.</span>constEnd());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        pub unsafe fn copy_from(
            &self,
            other: impl ::cpp_core::CastInto<
                ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
            >,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_6(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
                    >::cast_into(other)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator& QList<QQmlError>::const_iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#begin">QAssociativeIterable::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        pub unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__8(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::const_iterator::operator--(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator---1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix -- operator (<code>it--</code>) makes the preceding item current and returns an iterator to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn dec_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__9(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator& QList<QQmlError>::const_iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#end">QAssociativeIterable::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        pub unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__6(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// <p>This is an overloaded function.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::const_iterator::operator++(int arg1)```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
        /// <p>The postfix ++ operator (<code>it++</code>) advances the iterator to the next item in the container and returns an iterator to the previously current item.</p></div>
        #[inline(always)]
        pub unsafe fn inc_postfix(
            &self,
            arg1: ::std::os::raw::c_int,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__7(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                    arg1,
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::const_iterator::operator[](long long j) const```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-5b-5d">C++ documentation</a> for <span style='color: green;'>```QJsonValue const_iterator::operator[](int j) const```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at offset <i>j</i> from the item pointed to by this iterator (the item at position <code>*this + j</code>).</p>
        /// <p>This function is provided to make <a href="http://doc.qt.io/qt-5/qjsonarray.html">QJsonArray</a> iterators behave like C++ pointers.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-2b">operator+</a>().</p></div>
        #[inline(always)]
        pub unsafe fn index(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__1(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
                .expect("attempted to construct a null Ref")
        }

        /// <p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::const_iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p></div>
        #[inline(always)]
        pub unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
                .expect("attempted to construct a null Ref")
        }

        /// <p>Constructs an uninitialized iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::const_iterator::const_iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html#const_iterator">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an uninitialized iterator.</p>
        /// <p>Functions like operator*() and operator++() should not be called on an uninitialized iterator. Use operator=() to assign a value to it before using it.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>().</p></div>
        #[inline(always)]
        pub unsafe fn new_0a() -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result =
                { crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_const_iterator() };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::const_iterator::const_iterator(const QList<QQmlError>::iterator& o)```</span>.
        #[inline(always)]
        pub unsafe fn new_1a(
            o: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_const_iterator2(::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>::cast_into(o).as_raw_ptr())
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::const_iterator::const_iterator(const QList<QQmlError>::const_iterator& o)```</span>.
        #[inline(always)]
        pub unsafe fn new_copy(
            o: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_const_iterator1(
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
                    >::cast_into(o)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// <p>Returns a pointer to the current result.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QQmlError* QList<QQmlError>::const_iterator::operator->() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qfuture-const-iterator.html#operator--gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a pointer to the current result.</p></div>
        #[inline(always)]
        pub unsafe fn struct_deref(&self) -> ::cpp_core::Ptr<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator,
                )
            };
            ::cpp_core::Ptr::from_raw(ffi_result as *mut crate::QQmlError)
        }

        /// <p>Makes the iterator go back by <i>j</i> items.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator& QList<QQmlError>::const_iterator::operator-=(long long j)```</span>.
        ///
        /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--eq">C++ documentation</a> for <span style='color: green;'>```const_iterator &const_iterator::operator-=(int j)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Makes the iterator go back by <i>j</i> items.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-eq">operator+=</a>() and <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-">operator-</a>().</p></div>
        #[inline(always)]
        pub unsafe fn sub_assign(
            &self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__11(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                    j,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    /// C++ class: <span style='color: green;'>```QList<QQmlError>::MemoryLayout```</span>.
    #[repr(C)]
    pub struct MemoryLayout {
        _unused: u8,
    }
    impl MemoryLayout {
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::MemoryLayout& QList<QQmlError>::MemoryLayout::operator=(const QList<QQmlError>::MemoryLayout& other)```</span>.
        #[inline(always)]
        pub unsafe fn copy_from(
            &self,
            other: impl ::cpp_core::CastInto<
                ::cpp_core::Ref<crate::q_list_of_q_qml_error::MemoryLayout>,
            >,
        ) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::MemoryLayout> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_MemoryLayout_operator_(
                    self as *const crate::q_list_of_q_qml_error::MemoryLayout
                        as *mut crate::q_list_of_q_qml_error::MemoryLayout,
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_qml_error::MemoryLayout>,
                    >::cast_into(other)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::MemoryLayout::MemoryLayout()```</span>.
        #[inline(always)]
        pub unsafe fn new() -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::MemoryLayout> {
            let ffi_result =
                { crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_MemoryLayout_MemoryLayout() };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }

        /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::MemoryLayout::MemoryLayout(const QList<QQmlError>::MemoryLayout& other)```</span>.
        #[inline(always)]
        pub unsafe fn new_copy(
            other: impl ::cpp_core::CastInto<
                ::cpp_core::Ref<crate::q_list_of_q_qml_error::MemoryLayout>,
            >,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::MemoryLayout> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_MemoryLayout_MemoryLayout1(
                    ::cpp_core::CastInto::<
                        ::cpp_core::Ref<crate::q_list_of_q_qml_error::MemoryLayout>,
                    >::cast_into(other)
                    .as_raw_ptr(),
                )
            };
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }

    impl ::cpp_core::ops::Indirection for crate::q_list_of_q_qml_error::Iterator {
        type Output = ::cpp_core::Ref<crate::QQmlError>;
        /// <p>Returns a modifiable reference to the current item's value.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a modifiable reference to the current item's value.</p>
        /// <p>Same as <a href="http://doc.qt.io/qt-5/qhash-iterator.html#value">value</a>().</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#key">key</a>().</p></div>
        #[inline(always)]
        unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_(
                    self as *const crate::q_list_of_q_qml_error::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator==(const QList<QQmlError>::iterator& o) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-eq-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-not-eq">operator!=</a>().</p></div>
        #[inline(always)]
        fn eq(&self, o: &::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>) -> bool {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__2(
                    self as *const crate::q_list_of_q_qml_error::Iterator,
                    o.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator<(const QList<QQmlError>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn lt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_1(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator<=(const QList<QQmlError>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn le(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__4(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator>(const QList<QQmlError>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn gt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_2(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator>=(const QList<QQmlError>::iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn ge(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__5(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator==(const QList<QQmlError>::const_iterator& o) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-eq-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-not-eq">operator!=</a>().</p></div>
        #[inline(always)]
        fn eq(&self, o: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>) -> bool {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__6(
                    self as *const crate::q_list_of_q_qml_error::Iterator,
                    o.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator<(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn lt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_3(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator<=(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-lt-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn le(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__8(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator>(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn gt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_4(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::Iterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::iterator::operator>=(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-iterator.html#operator-gt-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn ge(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__9(
                self as *const crate::q_list_of_q_qml_error::Iterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::ops::Increment for crate::q_list_of_q_qml_error::Iterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>;
        /// <p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator& QList<QQmlError>::iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++i</code>) advances the iterator to the next item in the hash and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#end">QHash::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__10(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::cpp_core::ops::Decrement for crate::q_list_of_q_qml_error::Iterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>;
        /// <p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator& QList<QQmlError>::iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--i</code>) makes the preceding item current and returns an iterator pointing to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qhash.html#begin">QHash::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qhash-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator__12(
                    self as *const crate::q_list_of_q_qml_error::Iterator
                        as *mut crate::q_list_of_q_qml_error::Iterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::std::ops::Add<::std::os::raw::c_longlong> for &crate::q_list_of_q_qml_error::Iterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::iterator::operator+(long long j) const```</span>.
        #[inline(always)]
        fn add(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_5(
                        self as *const crate::q_list_of_q_qml_error::Iterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::std::os::raw::c_longlong> for &crate::q_list_of_q_qml_error::Iterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::iterator::operator-(long long j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_6(
                        self as *const crate::q_list_of_q_qml_error::Iterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>
        for &crate::q_list_of_q_qml_error::Iterator
    {
        type Output = ::std::os::raw::c_int;
        /// Calls C++ function: <span style='color: green;'>```int QList<QQmlError>::iterator::operator-(QList<QQmlError>::iterator j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>,
        ) -> ::std::os::raw::c_int {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_operator_7(
                    self as *const crate::q_list_of_q_qml_error::Iterator,
                    j.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::ops::Indirection for crate::q_list_of_q_qml_error::ConstIterator {
        type Output = ::cpp_core::Ref<crate::QQmlError>;
        /// <p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::const_iterator::operator*() const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the current value, converted to a <a href="http://doc.qt.io/qt-5/qvariant.html">QVariant</a>.</p></div>
        #[inline(always)]
        unsafe fn indirection(&self) -> ::cpp_core::Ref<crate::QQmlError> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
                .expect("attempted to construct a null Ref")
        }
    }

    impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::ConstIterator
    {
        /// <p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::const_iterator::operator==(const QList<QQmlError>::const_iterator& o) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-eq-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>other</i> points to the same item as this iterator; otherwise returns <code>false</code>.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-not-eq">operator!=</a>().</p></div>
        #[inline(always)]
        fn eq(&self, o: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>) -> bool {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__2(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator,
                    o.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::cmp::Lt<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::const_iterator::operator<(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-lt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn lt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_1(
                self as *const crate::q_list_of_q_qml_error::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Le<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::const_iterator::operator<=(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-lt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is less than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn le(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__4(
                self as *const crate::q_list_of_q_qml_error::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Gt<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::const_iterator::operator>(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn gt(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_2(
                self as *const crate::q_list_of_q_qml_error::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::cmp::Ge<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for crate::q_list_of_q_qml_error::ConstIterator
    {
        /// <p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::const_iterator::operator>=(const QList<QQmlError>::const_iterator& other) const```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qjsonarray-const-iterator.html#operator-gt-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the item pointed to by this iterator is greater than or equal to the item pointed to by the <i>other</i> iterator.</p></div>
        #[inline(always)]
        unsafe fn ge(
            &self,
            other: &::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> bool {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__5(
                self as *const crate::q_list_of_q_qml_error::ConstIterator,
                other.as_raw_ptr(),
            )
        }
    }

    impl ::cpp_core::ops::Increment for crate::q_list_of_q_qml_error::ConstIterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>;
        /// <p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator& QList<QQmlError>::const_iterator::operator++()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix ++ operator (<code>++it</code>) advances the iterator to the next item in the container and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#end">QAssociativeIterable::end</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">operator--</a>().</p></div>
        #[inline(always)]
        unsafe fn inc(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__6(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::cpp_core::ops::Decrement for crate::q_list_of_q_qml_error::ConstIterator {
        type Output = ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>;
        /// <p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator& QList<QQmlError>::const_iterator::operator--()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator--">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The prefix -- operator (<code>--it</code>) makes the preceding item current and returns an iterator to the new current item.</p>
        /// <p>Calling this function on <a href="http://doc.qt.io/qt-5/qassociativeiterable.html#begin">QAssociativeIterable::begin</a>() leads to undefined results.</p>
        /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qassociativeiterable-const-iterator.html#operator-2b-2b">operator++</a>().</p></div>
        #[inline(always)]
        unsafe fn dec(&self) -> ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator__8(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator
                        as *mut crate::q_list_of_q_qml_error::ConstIterator,
                )
            };
            ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
        }
    }

    impl ::std::ops::Add<::std::os::raw::c_longlong> for &crate::q_list_of_q_qml_error::ConstIterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::const_iterator::operator+(long long j) const```</span>.
        #[inline(always)]
        fn add(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_3(
                        self as *const crate::q_list_of_q_qml_error::ConstIterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::std::os::raw::c_longlong> for &crate::q_list_of_q_qml_error::ConstIterator {
        type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator>;
        /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::const_iterator::operator-(long long j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::std::os::raw::c_longlong,
        ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
            let ffi_result = {
                unsafe {
                    crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_4(
                        self as *const crate::q_list_of_q_qml_error::ConstIterator,
                        j,
                    )
                }
            };
            unsafe {
                ::cpp_core::CppBox::from_raw(ffi_result)
                    .expect("attempted to construct a null CppBox")
            }
        }
    }

    impl ::std::ops::Sub<::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>>
        for &crate::q_list_of_q_qml_error::ConstIterator
    {
        type Output = ::std::os::raw::c_int;
        /// Calls C++ function: <span style='color: green;'>```int QList<QQmlError>::const_iterator::operator-(QList<QQmlError>::const_iterator j) const```</span>.
        #[inline(always)]
        fn sub(
            self,
            j: ::cpp_core::Ref<crate::q_list_of_q_qml_error::ConstIterator>,
        ) -> ::std::os::raw::c_int {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_operator_5(
                    self as *const crate::q_list_of_q_qml_error::ConstIterator,
                    j.as_raw_ptr(),
                )
            }
        }
    }

    impl ::cpp_core::CppDeletable for crate::q_list_of_q_qml_error::Iterator {
        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QQmlError>::iterator::~iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> class provides an STL-style non-const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> features both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;) and to modify the list item associated with the iterator. If you want to iterate over a const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>, use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#begin">QList::begin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#end">QList::end</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Let's see a few examples of things we can do with a <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> that we cannot do with a <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a>. Here's an example that increments every value stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;int&gt; by 2:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span><span class="operator">::</span>iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>begin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>end(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     <span class="operator">*</span>i <span class="operator">+</span><span class="operator">=</span> <span class="number">2</span>;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>begin()<span class="operator">,</span> list<span class="operator">.</span>end());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        unsafe fn delete(&self) {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_iterator_diterator(
                self as *const crate::q_list_of_q_qml_error::Iterator
                    as *mut crate::q_list_of_q_qml_error::Iterator,
            )
        }
    }

    impl ::cpp_core::CppDeletable for crate::q_list_of_q_qml_error::ConstIterator {
        /// <p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        ///
        /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QQmlError>::const_iterator::~const_iterator()```</span>.
        ///
        /// <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> class provides an STL-style const iterator for <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> and <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides both <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> and <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a>. The STL-style iterators are more low-level and more cumbersome to use; on the other hand, they are slightly faster and, for developers who already know STL, have the advantage of familiarity.</p>
        /// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;::const_iterator allows you to iterate over a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; (or a <a href="http://doc.qt.io/qt-5/qqueue.html">QQueue</a>&lt;T&gt;). If you want to modify the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as you iterate over it, use <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a> instead. It is generally good practice to use <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> on a non-const <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as well, unless you need to change the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> through the iterator. Const iterators are slightly faster, and can improve code readability.</p>
        /// <p>The default <a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> constructor creates an uninitialized iterator. You must initialize it using a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> function like <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">QList::constBegin</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">QList::constEnd</a>(), or <a href="http://doc.qt.io/qt-5/qlist.html#insert">QList::insert</a>() before you can start iterating. Here's a typical loop that prints all the items stored in a list:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
        ///   list<span class="operator">.</span>append(<span class="string">"January"</span>);
        ///   list<span class="operator">.</span>append(<span class="string">"February"</span>);
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   list<span class="operator">.</span>append(<span class="string">"December"</span>);
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span><span class="operator">::</span>const_iterator i;
        ///   <span class="keyword">for</span> (i <span class="operator">=</span> list<span class="operator">.</span>constBegin(); i <span class="operator">!</span><span class="operator">=</span> list<span class="operator">.</span>constEnd(); <span class="operator">+</span><span class="operator">+</span>i)
        /// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="operator">*</span>i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
        ///
        /// </pre>
        /// <p>Most <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> functions accept an integer index rather than an iterator. For that reason, iterators are rarely useful in connection with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. One place where STL-style iterators do make sense is as arguments to <a href="http://doc.qt.io/qt-5/qtalgorithms.html">generic algorithms</a>.</p>
        /// <p>For example, here's how to delete all the widgets stored in a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *&gt;:</p>
        /// <pre class="cpp">
        ///
        ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
        ///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
        ///   <a href="http://doc.qt.io/qt-5/qtalgorithms.html#qDeleteAll">qDeleteAll</a>(list<span class="operator">.</span>constBegin()<span class="operator">,</span> list<span class="operator">.</span>constEnd());
        ///
        /// </pre>
        /// <p>Multiple iterators can be used on the same list. However, be aware that any non-const function call performed on the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> will render all existing iterators undefined. If you need to keep iterators over a long period of time, we recommend that you use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> rather than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
        /// <p><b>Warning:</b> Iterators on implicitly shared containers do not work exactly like STL-iterators. You should avoid copying a container while iterators are active on that container. For more information, read <a href="http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem">Implicit sharing iterator problem</a>.</p></div>
        #[inline(always)]
        unsafe fn delete(&self) {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_const_iterator_dconst_iterator(
                self as *const crate::q_list_of_q_qml_error::ConstIterator
                    as *mut crate::q_list_of_q_qml_error::ConstIterator,
            )
        }
    }

    impl ::cpp_core::CppDeletable for crate::q_list_of_q_qml_error::MemoryLayout {
        /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QQmlError>::MemoryLayout::~MemoryLayout()```</span>.
        #[inline(always)]
        unsafe fn delete(&self) {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_MemoryLayout_dMemoryLayout(
                self as *const crate::q_list_of_q_qml_error::MemoryLayout
                    as *mut crate::q_list_of_q_qml_error::MemoryLayout,
            )
        }
    }
}
/// <p>The <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> class is a template class that provides lists.</p>
///
/// C++ class: <span style='color: green;'>```QList<QQmlError>```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qlist.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> class is a template class that provides lists.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; is one of Qt's generic <a href="http://doc.qt.io/qt-5/containers.html">container classes</a>. It stores items in a list that provides fast index-based access and index-based insertions and removals.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;, <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a>&lt;T&gt;, and <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; provide similar APIs and functionality. They are often interchangeable, but there are performance consequences. Here is an overview of use cases:</p>
/// <ul>
/// <li><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> should be your default first choice. <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; will usually give better performance than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;, because <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; always stores its items sequentially in memory, where <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; will allocate its items on the heap unless <code>sizeof(T) &lt;= sizeof(void*)</code> and T has been declared to be either a <code>Q_MOVABLE_TYPE</code> or a <code>Q_PRIMITIVE_TYPE</code> using <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_DECLARE_TYPEINFO">Q_DECLARE_TYPEINFO</a>. See the <a href="http://marcmutz.wordpress.com/effective-qt/containers/#containers-qlist">Pros and Cons of Using QList</a> for an explanation.</li>
/// <li>However, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is used throughout the Qt APIs for passing parameters and for returning values. Use <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> to interface with those APIs.</li>
/// <li>If you need a real linked list, which guarantees <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a> insertions mid-list and uses iterators to items rather than indexes, use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a>.</li>
/// </ul>
/// <p><b>Note: </b><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> and <a href="http://doc.qt.io/qt-5/qvarlengtharray.html">QVarLengthArray</a> both guarantee C-compatible array layout. <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> does not. This might be important if your application must interface with a C API.</p><p><b>Note: </b>Iterators into a <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> and references into heap-allocating QLists remain valid as long as the referenced items remain in the container. This is not true for iterators and references into a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> and non-heap-allocating QLists.</p><p>Internally, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; is represented as an array of T if <code>sizeof(T) &lt;= sizeof(void*)</code> and T has been declared to be either a <code>Q_MOVABLE_TYPE</code> or a <code>Q_PRIMITIVE_TYPE</code> using <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_DECLARE_TYPEINFO">Q_DECLARE_TYPEINFO</a>. Otherwise, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; is represented as an array of T* and the items are allocated on the heap.</p>
/// <p>The array representation allows very fast insertions and index-based access. The <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>() operations are also very fast because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates memory at both ends of its internal array. (See <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">Algorithmic Complexity</a> for details.</p>
/// <p>Note, however, that when the conditions specified above are not met, each append or insert of a new item requires allocating the new item on the heap, and this per item allocation will make <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> a better choice for use cases that do a lot of appending or inserting, because <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> can allocate memory for many items in a single heap allocation.</p>
/// <p>Note that the internal array only ever gets bigger over the life of the list. It never shrinks. The internal array is deallocated by the destructor and by the assignment operator, when one list is assigned to another.</p>
/// <p>Here's an example of a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> that stores integers and a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> that stores <a href="http://doc.qt.io/qt-5/qdate.html">QDate</a> values:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span> integerList;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qdate.html">QDate</a></span><span class="operator">&gt;</span> dateList;
///
/// </pre>
/// <p>Qt includes a <a href="http://doc.qt.io/qt-5/qstringlist.html">QStringList</a> class that inherits <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;<a href="http://doc.qt.io/qt-5/qstring.html">QString</a>&gt; and adds a few convenience functions, such as <a href="http://doc.qt.io/qt-5/qstringlist.html#join">QStringList::join</a>() and <a href="http://doc.qt.io/qt-5/qstringlist.html#filter">QStringList::filter</a>(). <a href="http://doc.qt.io/qt-5/qstring.html#split">QString::split</a>() creates QStringLists from strings.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> stores a list of items. The default constructor creates an empty list. To insert items into the list, you can use operator&lt;&lt;():</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"one"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"two"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"three"</span>;
///   <span class="comment">// list: ["one", "two", "three"]</span>
///
/// </pre>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides these basic functions to add, move, and remove items: <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#replace">replace</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#move">move</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#swap">swap</a>(). In addition, it provides the following convenience functions: <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>().</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> uses 0-based indexes, just like C++ arrays. To access the item at a particular index position, you can use operator[](). On non-const lists, operator[]() returns a reference to the item and can be used on the left side of an assignment:</p>
/// <pre class="cpp">
///
///   <span class="keyword">if</span> (list<span class="operator">[</span><span class="number">0</span><span class="operator">]</span> <span class="operator">=</span><span class="operator">=</span> <span class="string">"Bob"</span>)
/// &#32;     list<span class="operator">[</span><span class="number">0</span><span class="operator">]</span> <span class="operator">=</span> <span class="string">"Robert"</span>;
///
/// </pre>
/// <p>Because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is implemented as an array of pointers for types that are larger than a pointer or are not movable, this operation requires (<a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>). For read-only access, an alternative syntax is to use <a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>():</p>
/// <pre class="cpp">
///
///   <span class="keyword">for</span> (<span class="type">int</span> i <span class="operator">=</span> <span class="number">0</span>; i <span class="operator">&lt;</span> list<span class="operator">.</span>size(); <span class="operator">+</span><span class="operator">+</span>i) {
/// &#32;     <span class="keyword">if</span> (list<span class="operator">.</span>at(i) <span class="operator">=</span><span class="operator">=</span> <span class="string">"Jane"</span>)
/// &#32;   &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"Found Jane at position "</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
///   }
///
/// </pre>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() can be faster than operator[](), because it never causes a <a href="http://doc.qt.io/qt-5/implicit-sharing.html#deep-copy">deep copy</a> to occur.</p>
/// <p>A common requirement is to remove an item from a list and do something with it. For this, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>(). Here's a loop that removes the items from a list one at a time and calls <code>delete</code> on them:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a></span> <span class="operator">*</span><span class="operator">&gt;</span> list;
///   <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>
///   <span class="keyword">while</span> (<span class="operator">!</span>list<span class="operator">.</span>isEmpty())
/// &#32;     <span class="keyword">delete</span> list<span class="operator">.</span>takeFirst();
///
/// </pre>
/// <p>Inserting and removing items at either end of the list is very fast (<a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a> in most cases), because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates extra space on both sides of its internal buffer to allow for fast growth at both ends of the list.</p>
/// <p>If you want to find all occurrences of a particular value in a list, use <a href="http://doc.qt.io/qt-5/qlist.html#indexOf">indexOf</a>() or <a href="http://doc.qt.io/qt-5/qlist.html#lastIndexOf">lastIndexOf</a>(). The former searches forward starting from a given index position, the latter searches backward. Both return the index of a matching item if they find it; otherwise, they return -1. For example:</p>
/// <pre class="cpp">
///
///   <span class="type">int</span> i <span class="operator">=</span> list<span class="operator">.</span>indexOf(<span class="string">"Jane"</span>);
///   <span class="keyword">if</span> (i <span class="operator">!</span><span class="operator">=</span> <span class="operator">-</span><span class="number">1</span>)
/// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"First occurrence of Jane is at position "</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
///
/// </pre>
/// <p>If you simply want to check whether a list contains a particular value, use <a href="http://doc.qt.io/qt-5/qlist.html#contains">contains</a>(). If you want to find out how many times a particular value occurs in the list, use <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>(). If you want to replace all occurrences of a particular value with another, use <a href="http://doc.qt.io/qt-5/qlist.html#replace">replace</a>().</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>'s value type must be an <a href="http://doc.qt.io/qt-5/containers.html#assignable-data-type">assignable data type</a>. This covers most data types that are commonly used, but the compiler won't let you, for example, store a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> as a value; instead, store a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *. A few functions have additional requirements; for example, <a href="http://doc.qt.io/qt-5/qlist.html#indexOf">indexOf</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#lastIndexOf">lastIndexOf</a>() expect the value type to support <code>operator==()</code>. These requirements are documented on a per-function basis.</p>
/// <p>Like the other container classes, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> provides <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a> (<a href="http://doc.qt.io/qt-5/qlistiterator.html">QListIterator</a> and <a href="http://doc.qt.io/qt-5/qmutablelistiterator.html">QMutableListIterator</a>) and <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> (<a href="http://doc.qt.io/qt-5/qlist-const-iterator.html">QList::const_iterator</a> and <a href="http://doc.qt.io/qt-5/qlist-iterator.html">QList::iterator</a>). In practice, these are rarely used, because you can use indexes into the <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>. <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is implemented in such a way that direct index-based access is just as fast as using iterators.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a> does <i>not</i> support inserting, prepending, appending or replacing with references to its own values. Doing so will cause your application to abort with an error message.</p>
/// <p>To make <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> as efficient as possible, its member functions don't validate their input before using it. Except for <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>(), member functions always assume the list is <i>not</i> empty. Member functions that take index values as parameters always assume their index value parameters are in the valid range. This means <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> member functions can fail. If you define QT_NO_DEBUG when you compile, failures will not be detected. If you <i>don't</i> define QT_NO_DEBUG, failures will be detected using <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_ASSERT">Q_ASSERT</a>() or <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_ASSERT_X">Q_ASSERT_X</a>() with an appropriate message.</p>
/// <p>To avoid failures when your list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling other member functions. If you must pass an index value that might not be in the valid range, check that it is less than the value returned by <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() but <i>not</i> less than 0.</p>
/// <a name="more-members"></a></div>
#[repr(C)]
pub struct QListOfQQmlError {
    _unused: u8,
}
impl QListOfQQmlError {
    /// <p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>& QList<QQmlError>::operator+=(const QList<QQmlError>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-2b">operator+</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>().</p></div>
    #[inline(always)]
    pub unsafe fn add_assign_q_list_of_q_qml_error(
        &self,
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) -> ::cpp_core::Ref<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator__4(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(l)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>& QList<QQmlError>::operator+=(const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends <i>value</i> to the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">operator&lt;&lt;</a>().</p></div>
    #[inline(always)]
    pub unsafe fn add_assign_q_qml_error(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) -> ::cpp_core::Ref<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator__5(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Inserts <i>value</i> at the end of the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::append(const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#append">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at the end of the list.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>append(<span class="string">"one"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"two"</span>);
    ///   list<span class="operator">.</span>append(<span class="string">"three"</span>);
    ///   <span class="comment">// list: ["one", "two", "three"]</span>
    ///
    /// </pre>
    /// <p>This is the same as list.insert(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(), <i>value</i>).</p>
    /// <p>If this list is not shared, this operation is typically very fast (amortized <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>), because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates extra space on both sides of its internal buffer to allow for fast growth at both ends of the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">operator&lt;&lt;</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>().</p></div>
    #[inline(always)]
    pub unsafe fn append_q_qml_error(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_append(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::append(const QList<QQmlError>& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#append-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends the items of the <i>value</i> list to this list.</p>
    /// <p>This function was introduced in  Qt 4.5.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">operator&lt;&lt;</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">operator+=</a>().</p></div>
    #[inline(always)]
    pub unsafe fn append_q_list_of_q_qml_error(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_append1(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(t)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns the item at index position <i>i</i> in the list. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::at(int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#at">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at index position <i>i</i> in the list. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p>This function is very fast (<a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#value">value</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    pub unsafe fn at(&self, i: ::std::os::raw::c_int) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_at(
                self as *const crate::QListOfQQmlError,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::back()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn back_mut(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_back(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::back() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#back-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn back(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_back1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::begin()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    pub unsafe fn begin_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_begin(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::begin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn begin(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_begin1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::cbegin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#cbegin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p>This function was introduced in  Qt 5.0.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#cend">cend</a>().</p></div>
    #[inline(always)]
    pub unsafe fn cbegin(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_cbegin(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::cend() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#cend">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p>This function was introduced in  Qt 5.0.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#cbegin">cbegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    pub unsafe fn cend(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_cend(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes all items from the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::clear()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#clear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes all items from the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAll">removeAll</a>().</p></div>
    #[inline(always)]
    pub unsafe fn clear(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_clear(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::constBegin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constBegin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">constEnd</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_begin(
        &self,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_constBegin(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::constEnd() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_end(
        &self,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_constEnd(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a const reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::constFirst() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constLast">constLast</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_first(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_constFirst(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::constLast() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#constLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constFirst">constFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>().</p></div>
    #[inline(always)]
    pub unsafe fn const_last(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_constLast(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Assigns <i>other</i> to this list and returns a reference to this list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>& QList<QQmlError>::operator=(const QList<QQmlError>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns <i>other</i> to this list and returns a reference to this list.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from(
        &self,
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) -> ::cpp_core::Ref<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator_(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(l)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns the number of items in the list. This is effectively the same as <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QQmlError>::count() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#count-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the list. This is effectively the same as <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p></div>
    #[inline(always)]
    pub unsafe fn count(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_count1(self as *const crate::QListOfQQmlError)
    }

    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::detach()```</span>.
    #[inline(always)]
    pub unsafe fn detach(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_detach(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::detachShared()```</span>.
    #[inline(always)]
    pub unsafe fn detach_shared(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_detachShared(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and returns <code>true</code> if the list is empty.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::empty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#empty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and returns <code>true</code> if the list is empty.</p></div>
    #[inline(always)]
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_empty(self as *const crate::QListOfQQmlError)
    }

    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::end()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">constEnd</a>().</p></div>
    #[inline(always)]
    pub unsafe fn end_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_end(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::end() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn end(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_end1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the item associated with the iterator <i>pos</i> from the list, and returns an iterator to the next item in the list (which may be <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::erase(QList<QQmlError>::iterator pos)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#erase">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the item associated with the iterator <i>pos</i> from the list, and returns an iterator to the next item in the list (which may be <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn erase_1a(
        &self,
        pos: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_erase(self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>::cast_into(pos).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::erase(QList<QQmlError>::iterator first, QList<QQmlError>::iterator last)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#erase-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Removes all the items from <i>begin</i> up to (but not including) <i>end</i>. Returns an iterator to the same item that <i>end</i> referred to before the call.</p></div>
    #[inline(always)]
    pub unsafe fn erase_2a(
        &self,
        first: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>,
        last: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_erase1(self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>::cast_into(first).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>::cast_into(last).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::first()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#first">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the first item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constFirst">constFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#last">last</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn first_mut(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_first(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::first() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#first-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn first(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_first1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::front()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn front_mut(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_front(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::front() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#front-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn front(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_front1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::operator[](int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Same as <a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>(). This function runs in <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>.</p></div>
    #[inline(always)]
    pub unsafe fn index(&self, i: ::std::os::raw::c_int) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator__2(
                self as *const crate::QListOfQQmlError,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns the item at index position <i>i</i> as a modifiable reference. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::operator[](int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at index position <i>i</i> as a modifiable reference. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p>If this function is called on a list that is currently being shared, it will trigger a copy of all elements. Otherwise, this function runs in <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>. If you do not want to modify the list you should use <a href="http://doc.qt.io/qt-5/qlist.html#at">QList::at</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#value">value</a>().</p></div>
    #[inline(always)]
    pub unsafe fn index_mut(&self, i: ::std::os::raw::c_int) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator__3(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Inserts <i>value</i> at index position <i>i</i> in the list. If <i>i</i> &lt;= 0, the value is prepended to the list. If <i>i</i> &gt;= <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(), the value is appended to the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::insert(int i, const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#insert">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at index position <i>i</i> in the list. If <i>i</i> &lt;= 0, the value is prepended to the list. If <i>i</i> &gt;= <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(), the value is appended to the list.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"alpha"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"beta"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"delta"</span>;
    ///   list<span class="operator">.</span>insert(<span class="number">2</span><span class="operator">,</span> <span class="string">"gamma"</span>);
    ///   <span class="comment">// list: ["alpha", "beta", "gamma", "delta"]</span>
    ///
    /// </pre>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#replace">replace</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn insert_int_q_qml_error(
        &self,
        i: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_insert(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            i,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::insert(QList<QQmlError>::iterator before, const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#insert-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Inserts <i>value</i> in front of the item pointed to by the iterator <i>before</i>. Returns an iterator pointing at the inserted item. Note that the iterator passed to the function will be invalid after the call; the returned iterator should be used instead.</p></div>
    #[inline(always)]
    pub unsafe fn insert_iterator_q_qml_error(
        &self,
        before: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_insert1(self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_list_of_q_qml_error::Iterator>>::cast_into(before).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::isDetached() const```</span>.
    #[inline(always)]
    pub unsafe fn is_detached(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_isDetached(
            self as *const crate::QListOfQQmlError,
        )
    }

    /// <p>Returns <code>true</code> if the list contains no items; otherwise returns false.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::isEmpty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the list contains no items; otherwise returns false.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p></div>
    #[inline(always)]
    pub unsafe fn is_empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_isEmpty(self as *const crate::QListOfQQmlError)
    }

    /// Calls C++ function: <span style='color: green;'>```bool QList<QQmlError>::isSharedWith(const QList<QQmlError>& other) const```</span>.
    #[inline(always)]
    pub unsafe fn is_shared_with(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_isSharedWith(
            self as *const crate::QListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(other)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError& QList<QQmlError>::last()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#last">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the last item in the list. The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constLast">constLast</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#first">first</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>().</p></div>
    #[inline(always)]
    pub unsafe fn last_mut(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_last(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlError& QList<QQmlError>::last() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#last-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    pub unsafe fn last(&self) -> ::cpp_core::Ref<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_last1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::QQmlError)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is identical to <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QQmlError>::length() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#length">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is identical to <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p>
    /// <p>This function was introduced in  Qt 4.5.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p></div>
    #[inline(always)]
    pub unsafe fn length(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_length(self as *const crate::QListOfQQmlError)
    }

    /// <p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError> QList<QQmlError>::mid(int pos, int length = …) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#mid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p></div>
    #[inline(always)]
    pub unsafe fn mid_2a(
        &self,
        pos: ::std::os::raw::c_int,
        length: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_mid(
                self as *const crate::QListOfQQmlError,
                pos,
                length,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError> QList<QQmlError>::mid(int pos) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#mid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a sub-list which includes elements from this list, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements from <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p></div>
    #[inline(always)]
    pub unsafe fn mid_1a(
        &self,
        pos: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_mid1(
                self as *const crate::QListOfQQmlError,
                pos,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Moves the item at index position <i>from</i> to index position <i>to</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::move(int from, int to)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#move">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Moves the item at index position <i>from</i> to index position <i>to</i>.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"A"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"B"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"C"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"D"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"E"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"F"</span>;
    ///   list<span class="operator">.</span>move(<span class="number">1</span><span class="operator">,</span> <span class="number">4</span>);
    ///   <span class="comment">// list: ["A", "C", "D", "E", "B", "F"]</span>
    ///
    /// </pre>
    /// <p>This is the same as insert(<i>to</i>, <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(<i>from</i>)).This function assumes that both <i>from</i> and <i>to</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>from</i> and <i>to</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#swap">swap</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn move_(&self, from: ::std::os::raw::c_int, to: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_move(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            from,
            to,
        )
    }

    /// <p>Constructs an empty list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::QList()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#QList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an empty list.</p></div>
    #[inline(always)]
    pub unsafe fn new() -> ::cpp_core::CppBox<crate::QListOfQQmlError> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_QList() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a copy of <i>other</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QList<QQmlError>::QList(const QList<QQmlError>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#QList-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a copy of <i>other</i>.</p>
    /// <p>This operation takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>, because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is <a href="http://doc.qt.io/qt-5/implicit-sharing.html">implicitly shared</a>. This makes returning a <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), and that takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">linear time</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-eq">operator=</a>().</p></div>
    #[inline(always)]
    pub unsafe fn new_copy(
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) -> ::cpp_core::CppBox<crate::QListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_QList1(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(l)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::pop_back()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#pop_back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn pop_back(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_pop_back(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::pop_front()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#pop_front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p></div>
    #[inline(always)]
    pub unsafe fn pop_front(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_pop_front(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>Inserts <i>value</i> at the beginning of the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::prepend(const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#prepend">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at the beginning of the list.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list<span class="operator">.</span>prepend(<span class="string">"one"</span>);
    ///   list<span class="operator">.</span>prepend(<span class="string">"two"</span>);
    ///   list<span class="operator">.</span>prepend(<span class="string">"three"</span>);
    ///   <span class="comment">// list: ["three", "two", "one"]</span>
    ///
    /// </pre>
    /// <p>This is the same as list.insert(0, <i>value</i>).</p>
    /// <p>If this list is not shared, this operation is typically very fast (amortized <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>), because <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> preallocates extra space on both sides of its internal buffer to allow for fast growth at both ends of the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#insert">insert</a>().</p></div>
    #[inline(always)]
    pub unsafe fn prepend(&self, t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_prepend(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(<i>value</i>).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::push_back(const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#push_back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>(<i>value</i>).</p></div>
    #[inline(always)]
    pub unsafe fn push_back(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_push_back(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(<i>value</i>).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::push_front(const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#push_front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qlist.html#prepend">prepend</a>(<i>value</i>).</p></div>
    #[inline(always)]
    pub unsafe fn push_front(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_push_front(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>Removes the item at index position <i>i</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::removeAt(int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the item at index position <i>i</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeOne">removeOne</a>().</p></div>
    #[inline(always)]
    pub unsafe fn remove_at(&self, i: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_removeAt(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            i,
        )
    }

    /// <p>Removes the first item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(0). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::removeFirst()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the first item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(0). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>().</p></div>
    #[inline(always)]
    pub unsafe fn remove_first(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_removeFirst(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>Removes the last item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::removeLast()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the last item in the list. Calling this function is equivalent to calling <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). The list must not be empty. If the list can be empty, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>().</p></div>
    #[inline(always)]
    pub unsafe fn remove_last(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_removeLast(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>Replaces the item at index position <i>i</i> with <i>value</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::replace(int i, const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#replace">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Replaces the item at index position <i>i</i> with <i>value</i>. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">operator[]</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>().</p></div>
    #[inline(always)]
    pub unsafe fn replace(
        &self,
        i: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_replace(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            i,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(t).as_raw_ptr(),
        )
    }

    /// <p>Reserve space for <i>alloc</i> elements.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::reserve(int size)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#reserve">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Reserve space for <i>alloc</i> elements.</p>
    /// <p>If <i>alloc</i> is smaller than the current size of the list, nothing will happen.</p>
    /// <p>Use this function to avoid repetetive reallocation of <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>'s internal data if you can predict how many elements will be appended. Note that the reservation applies only to the internal pointer array.</p>
    /// <p>This function was introduced in  Qt 4.7.</p></div>
    #[inline(always)]
    pub unsafe fn reserve(&self, size: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_reserve(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::setSharable(bool sharable)```</span>.
    #[inline(always)]
    pub unsafe fn set_sharable(&self, sharable: bool) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_setSharable(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            sharable,
        )
    }

    /// <p>Returns the number of items in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QQmlError>::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p></div>
    #[inline(always)]
    pub unsafe fn size(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_size(self as *const crate::QListOfQQmlError)
    }

    /// <p>Swaps list <i>other</i> with this list. This operation is very fast and never fails.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::swap(QList<QQmlError>& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#swap">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Swaps list <i>other</i> with this list. This operation is very fast and never fails.</p>
    /// <p>This function was introduced in  Qt 4.8.</p></div>
    #[inline(always)]
    pub unsafe fn swap_1a(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_swap(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(other)
                .as_raw_ptr() as *mut crate::QListOfQQmlError,
        )
    }

    /// <p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::swap(int i, int j)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#swap-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"A"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"B"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"C"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"D"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"E"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"F"</span>;
    ///   list<span class="operator">.</span>swap(<span class="number">1</span><span class="operator">,</span> <span class="number">4</span>);
    ///   <span class="comment">// list: ["A", "E", "C", "D", "B", "F"]</span>
    ///
    /// </pre>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#move">move</a>().</p></div>
    #[inline(always)]
    pub unsafe fn swap_2a(&self, i: ::std::os::raw::c_int, j: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_swap1(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            i,
            j,
        )
    }

    /// <p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QList<QQmlError>::swapItemsAt(int i, int j)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#swapItemsAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>().</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qlist.html#QList">QList</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> list;
    ///   list <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"A"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"B"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"C"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"D"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"E"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"F"</span>;
    ///   list<span class="operator">.</span>swapItemsAt(<span class="number">1</span><span class="operator">,</span> <span class="number">4</span>);
    ///   <span class="comment">// list: ["A", "E", "C", "D", "B", "F"]</span>
    ///
    /// </pre>
    /// <p>This function was introduced in  Qt 5.13.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#move">move</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0")))
    )]
    #[cfg(any(
        any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0"),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn swap_items_at(&self, i: ::std::os::raw::c_int, j: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_swapItemsAt(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            i,
            j,
        )
    }

    /// <p>Removes the item at index position <i>i</i> and returns it. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError QList<QQmlError>::takeAt(int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the item at index position <i>i</i> and returns it. <i>i</i> must be a valid index position in the list (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>()).</p>
    /// <p>If you don't use the return value, <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>() is more efficient.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#removeAt">removeAt</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>().</p></div>
    #[inline(always)]
    pub unsafe fn take_at(&self, i: ::std::os::raw::c_int) -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_takeAt(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
                i,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the first item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(0). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError QList<QQmlError>::takeFirst()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the first item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(0). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>If this list is not shared, this operation takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>.</p>
    /// <p>If you don't use the return value, <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>() is more efficient.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#takeLast">takeLast</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeFirst">removeFirst</a>().</p></div>
    #[inline(always)]
    pub unsafe fn take_first(&self) -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_takeFirst(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the last item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError QList<QQmlError>::takeLast()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#takeLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the last item in the list and returns it. This is the same as <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(<a href="http://doc.qt.io/qt-5/qlist.html#size">size</a>() - 1). This function assumes the list is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>If this list is not shared, this operation takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>.</p>
    /// <p>If you don't use the return value, <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>() is more efficient.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#takeFirst">takeFirst</a>(), <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">takeAt</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#removeLast">removeLast</a>().</p></div>
    #[inline(always)]
    pub unsafe fn take_last(&self) -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_takeLast(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the value at index position <i>i</i> in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError QList<QQmlError>::value(int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#value">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value at index position <i>i</i> in the list.</p>
    /// <p>If the index <i>i</i> is out of bounds, the function returns a <a href="http://doc.qt.io/qt-5/containers.html#default-constructed-value">default-constructed value</a>. If you are certain that the index is going to be within bounds, you can use <a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() instead, which is slightly faster.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    pub unsafe fn value_1a(
        &self,
        i: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_value(
                self as *const crate::QListOfQQmlError,
                i,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlError QList<QQmlError>::value(int i, const QQmlError& defaultValue) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#value-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>If the index <i>i</i> is out of bounds, the function returns <i>defaultValue</i>.</p></div>
    #[inline(always)]
    pub unsafe fn value_2a(
        &self,
        i: ::std::os::raw::c_int,
        default_value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlError>>,
    ) -> ::cpp_core::CppBox<crate::QQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_value1(
                self as *const crate::QListOfQQmlError,
                i,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlError>>::cast_into(default_value)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p>The <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> class is a template class that provides a dynamic array.</p>
///
/// C++ class: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qvector.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> class is a template class that provides a dynamic array.</p>
/// <p><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; is one of Qt's generic <a href="http://doc.qt.io/qt-5/containers.html">container classes</a>. It stores its items in adjacent memory locations and provides fast index-based access.</p>
/// <p><a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;, <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a>&lt;T&gt;, <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt;, and <a href="http://doc.qt.io/qt-5/qvarlengtharray.html">QVarLengthArray</a>&lt;T&gt; provide similar APIs and functionality. They are often interchangeable, but there are performance consequences. Here is an overview of use cases:</p>
/// <ul>
/// <li><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> should be your default first choice. <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; will usually give better performance than <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt;, because <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>&lt;T&gt; always stores its items sequentially in memory, where <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>&lt;T&gt; will allocate its items on the heap unless <code>sizeof(T) &lt;= sizeof(void*)</code> and T has been declared to be either a <code>Q_MOVABLE_TYPE</code> or a <code>Q_PRIMITIVE_TYPE</code> using <a href="http://doc.qt.io/qt-5/qtglobal.html#Q_DECLARE_TYPEINFO">Q_DECLARE_TYPEINFO</a>. See the <a href="http://marcmutz.wordpress.com/effective-qt/containers/#containers-qlist">Pros and Cons of Using QList</a> for an explanation.</li>
/// <li>However, <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> is used throughout the Qt APIs for passing parameters and for returning values. Use <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> to interface with those APIs.</li>
/// <li>If you need a real linked list, which guarantees <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a> insertions mid-list and uses iterators to items rather than indexes, use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a>.</li>
/// </ul>
/// <p><b>Note: </b><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> and <a href="http://doc.qt.io/qt-5/qvarlengtharray.html">QVarLengthArray</a> both guarantee C-compatible array layout. <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> does not. This might be important if your application must interface with a C API.</p><p><b>Note: </b>Iterators into a <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> and references into heap-allocating QLists remain valid as long as the referenced items remain in the container. This is not true for iterators and references into a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> and non-heap-allocating QLists.</p><p>Here's an example of a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> that stores integers and a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> that stores <a href="http://doc.qt.io/qt-5/qstring.html">QString</a> values:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span> integerVector;
///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> stringVector;
///
/// </pre>
/// <p><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> stores its items in a vector (array). Typically, vectors are created with an initial size. For example, the following code constructs a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> with 200 elements:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> vector(<span class="number">200</span>);
///
/// </pre>
/// <p>The elements are automatically initialized with a <a href="http://doc.qt.io/qt-5/containers.html#default-constructed-value">default-constructed value</a>. If you want to initialize the vector with a different value, pass that value as the second argument to the constructor:</p>
/// <pre class="cpp">
///
///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> vector(<span class="number">200</span><span class="operator">,</span> <span class="string">"Pass"</span>);
///
/// </pre>
/// <p>You can also call <a href="http://doc.qt.io/qt-5/qvector.html#fill">fill</a>() at any time to fill the vector with a value.</p>
/// <p><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> uses 0-based indexes, just like C++ arrays. To access the item at a particular index position, you can use operator[](). On non-const vectors, operator[]() returns a reference to the item that can be used on the left side of an assignment:</p>
/// <pre class="cpp">
///
///   <span class="keyword">if</span> (vector<span class="operator">[</span><span class="number">0</span><span class="operator">]</span> <span class="operator">=</span><span class="operator">=</span> <span class="string">"Liz"</span>)
/// &#32;     vector<span class="operator">[</span><span class="number">0</span><span class="operator">]</span> <span class="operator">=</span> <span class="string">"Elizabeth"</span>;
///
/// </pre>
/// <p>For read-only access, an alternative syntax is to use <a href="http://doc.qt.io/qt-5/qvector.html#at">at</a>():</p>
/// <pre class="cpp">
///
///   <span class="keyword">for</span> (<span class="type">int</span> i <span class="operator">=</span> <span class="number">0</span>; i <span class="operator">&lt;</span> vector<span class="operator">.</span>size(); <span class="operator">+</span><span class="operator">+</span>i) {
/// &#32;     <span class="keyword">if</span> (vector<span class="operator">.</span>at(i) <span class="operator">=</span><span class="operator">=</span> <span class="string">"Alfonso"</span>)
/// &#32;   &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"Found Alfonso at position "</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
///   }
///
/// </pre>
/// <p><a href="http://doc.qt.io/qt-5/qvector.html#at">at</a>() can be faster than operator[](), because it never causes a <a href="http://doc.qt.io/qt-5/implicit-sharing.html#deep-copy">deep copy</a> to occur.</p>
/// <p>Another way to access the data stored in a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> is to call <a href="http://doc.qt.io/qt-5/qvector.html#data">data</a>(). The function returns a pointer to the first item in the vector. You can use the pointer to directly access and modify the elements stored in the vector. The pointer is also useful if you need to pass a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> to a function that accepts a plain C++ array.</p>
/// <p>If you want to find all occurrences of a particular value in a vector, use <a href="http://doc.qt.io/qt-5/qvector.html#indexOf">indexOf</a>() or <a href="http://doc.qt.io/qt-5/qvector.html#lastIndexOf">lastIndexOf</a>(). The former searches forward starting from a given index position, the latter searches backward. Both return the index of the matching item if they found one; otherwise, they return -1. For example:</p>
/// <pre class="cpp">
///
///   <span class="type">int</span> i <span class="operator">=</span> vector<span class="operator">.</span>indexOf(<span class="string">"Harumi"</span>);
///   <span class="keyword">if</span> (i <span class="operator">!</span><span class="operator">=</span> <span class="operator">-</span><span class="number">1</span>)
/// &#32;     cout <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"First occurrence of Harumi is at position "</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> i <span class="operator">&lt;</span><span class="operator">&lt;</span> endl;
///
/// </pre>
/// <p>If you simply want to check whether a vector contains a particular value, use <a href="http://doc.qt.io/qt-5/qvector.html#contains">contains</a>(). If you want to find out how many times a particular value occurs in the vector, use <a href="http://doc.qt.io/qt-5/qvector.html#count-1">count</a>().</p>
/// <p><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> provides these basic functions to add, move, and remove items: <a href="http://doc.qt.io/qt-5/qvector.html#insert">insert</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#replace">replace</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#remove">remove</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#prepend">prepend</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>(). With the exception of <a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#replace">replace</a>(), these functions can be slow (<a href="http://doc.qt.io/qt-5/containers.html#linear-time">linear time</a>) for large vectors, because they require moving many items in the vector by one position in memory. If you want a container class that provides fast insertion/removal in the middle, use <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> or <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> instead.</p>
/// <p>Unlike plain C++ arrays, QVectors can be resized at any time by calling <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>(). If the new size is larger than the old size, <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> might need to reallocate the whole vector. <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> tries to reduce the number of reallocations by preallocating up to twice as much memory as the actual data needs.</p>
/// <p>If you know in advance approximately how many items the <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> will contain, you can call <a href="http://doc.qt.io/qt-5/qvector.html#reserve">reserve</a>(), asking <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> to preallocate a certain amount of memory. You can also call <a href="http://doc.qt.io/qt-5/qvector.html#capacity">capacity</a>() to find out how much memory <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> actually allocated.</p>
/// <p>Note that using non-const operators and functions can cause <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> to do a deep copy of the data. This is due to <a href="http://doc.qt.io/qt-5/implicit-sharing.html">implicit sharing</a>.</p>
/// <p><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>'s value type must be an <a href="http://doc.qt.io/qt-5/containers.html#assignable-data-type">assignable data type</a>. This covers most data types that are commonly used, but the compiler won't let you, for example, store a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> as a value; instead, store a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *. A few functions have additional requirements; for example, <a href="http://doc.qt.io/qt-5/qvector.html#indexOf">indexOf</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#lastIndexOf">lastIndexOf</a>() expect the value type to support <code>operator==()</code>. These requirements are documented on a per-function basis.</p>
/// <p>Like the other container classes, <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> provides <a href="http://doc.qt.io/qt-5/containers.html#java-style-iterators">Java-style iterators</a> (<a href="http://doc.qt.io/qt-5/qvectoriterator.html">QVectorIterator</a> and <a href="http://doc.qt.io/qt-5/qmutablevectoriterator.html">QMutableVectorIterator</a>) and <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterators</a> (<a href="http://doc.qt.io/qt-5/qvector.html#const_iterator-typedef">QVector::const_iterator</a> and <a href="http://doc.qt.io/qt-5/qvector.html#iterator-typedefx">QVector::iterator</a>). In practice, these are rarely used, because you can use indexes into the <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>.</p>
/// <p>In addition to <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>, Qt also provides <a href="http://doc.qt.io/qt-5/qvarlengtharray.html">QVarLengthArray</a>, a very low-level class with little functionality that is optimized for speed.</p>
/// <p><a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> does <i>not</i> support inserting, prepending, appending or replacing with references to its own values. Doing so will cause your application to abort with an error message.</p>
/// <a name="more-information-on-using-qt-containers"></a>
/// <h4>More Information on Using Qt Containers</h4>
/// <p>For a detailed discussion comparing Qt containers with each other and with STL containers, see <a href="http://marcmutz.wordpress.com/effective-qt/containers/">Understand the Qt Containers</a>.</p></div>
#[repr(C)]
pub struct QVectorOfPropertyPair {
    _unused: u8,
}
impl QVectorOfPropertyPair {
    /// <p>Appends the items of the <i>other</i> vector to this vector and returns a reference to this vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>& QVector<QQmlContext::PropertyPair>::operator+=(const QVector<QQmlContext::PropertyPair>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-2b-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends the items of the <i>other</i> vector to this vector and returns a reference to this vector.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#operator-2b">operator+</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn add_assign_q_vector_of_property_pair(
        &self,
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QVectorOfPropertyPair>>,
    ) -> ::cpp_core::Ref<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator__4(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QVectorOfPropertyPair>>::cast_into(l)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>& QVector<QQmlContext::PropertyPair>::operator+=(const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-2b-eq-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends <i>value</i> to the vector.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-lt-lt">operator&lt;&lt;</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn add_assign_property_pair(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) -> ::cpp_core::Ref<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator__5(self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(t).as_raw_ptr())
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Inserts <i>value</i> at the end of the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::append(const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#append">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at the end of the vector.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> vector;
    ///   vector<span class="operator">.</span>append(<span class="string">"one"</span>);
    ///   vector<span class="operator">.</span>append(<span class="string">"two"</span>);
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span> three <span class="operator">=</span> <span class="string">"three"</span>;
    ///   vector<span class="operator">.</span>append(three);
    ///   <span class="comment">// vector: ["one", "two", "three"]</span>
    ///   <span class="comment">// three: "three"</span>
    ///
    /// </pre>
    /// <p>This is the same as calling resize(<a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>() + 1) and assigning <i>value</i> to the new last element in the vector.</p>
    /// <p>This operation is relatively fast, because <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> typically allocates more memory than necessary, so it can grow without reallocating the entire vector each time.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#operator-lt-lt">operator&lt;&lt;</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#prepend">prepend</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#insert">insert</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn append_property_pair(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_append(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(
                t,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::append(const QVector<QQmlContext::PropertyPair>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#append-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends the items of the <i>value</i> vector to this vector.</p>
    /// <p>This function was introduced in  Qt 5.5.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#operator-lt-lt">operator&lt;&lt;</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-2b-eq">operator+=</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn append_q_vector_of_property_pair(
        &self,
        l: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QVectorOfPropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_append2(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QVectorOfPropertyPair>>::cast_into(l)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns the item at index position <i>i</i> in the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::at(int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#at">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at index position <i>i</i> in the vector.</p>
    /// <p><i>i</i> must be a valid index position in the vector (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#value">value</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn at(
        &self,
        i: ::std::os::raw::c_int,
    ) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_at(
                self as *const crate::QVectorOfPropertyPair,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#last">last</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::back()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#last">last</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn back_mut(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_back(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::back() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#back-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn back(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_back1(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns the maximum number of items that can be stored in the vector without forcing a reallocation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QVector<QQmlContext::PropertyPair>::capacity() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#capacity">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the maximum number of items that can be stored in the vector without forcing a reallocation.</p>
    /// <p>The sole purpose of this function is to provide a means of fine tuning <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>'s memory usage. In general, you will rarely ever need to call this function. If you want to know how many items are in the vector, call <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#reserve">reserve</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#squeeze">squeeze</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn capacity(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_capacity(
            self as *const crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Removes all the elements from the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::clear()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#clear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes all the elements from the vector.</p>
    /// <p><b>Note: </b>Until Qt 5.6, this also released the memory used by the vector. From Qt 5.7, the capacity is preserved. To shed all capacity, swap with a default-constructed vector:</p><pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span>T<span class="operator">&gt;</span> v <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>;
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span>T<span class="operator">&gt;</span>()<span class="operator">.</span>swap(v);
    ///   Q_ASSERT(v<span class="operator">.</span>capacity() <span class="operator">=</span><span class="operator">=</span> <span class="number">0</span>);
    ///
    /// </pre>
    /// <p>or call <a href="http://doc.qt.io/qt-5/qvector.html#squeeze">squeeze</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#squeeze">squeeze</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn clear(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_clear(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Returns a const pointer to the data stored in the vector. The pointer can be used to access the items in the vector. The pointer remains valid as long as the vector isn't reallocated.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair* QVector<QQmlContext::PropertyPair>::constData() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#constData">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const pointer to the data stored in the vector. The pointer can be used to access the items in the vector. The pointer remains valid as long as the vector isn't reallocated.</p>
    /// <p>This function is mostly useful to pass a vector to a function that accepts a plain C++ array.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#data">data</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn const_data(&self) -> ::cpp_core::Ptr<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_constData(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
    }

    /// <p>Returns a const reference to the first item in the vector. This function assumes that the vector isn't empty.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::constFirst() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#constFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const reference to the first item in the vector. This function assumes that the vector isn't empty.</p>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#constLast">constLast</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#first">first</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn const_first(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_constFirst(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns a const reference to the last item in the vector. This function assumes that the vector isn't empty.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::constLast() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#constLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a const reference to the last item in the vector. This function assumes that the vector isn't empty.</p>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#constFirst">constFirst</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#last">last</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn const_last(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_constLast(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Assigns <i>other</i> to this vector and returns a reference to this vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>& QVector<QQmlContext::PropertyPair>::operator=(const QVector<QQmlContext::PropertyPair>& v)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns <i>other</i> to this vector and returns a reference to this vector.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn copy_from(
        &self,
        v: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QVectorOfPropertyPair>>,
    ) -> ::cpp_core::Ref<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator_(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QVectorOfPropertyPair>>::cast_into(v)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QVector<QQmlContext::PropertyPair>::count() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#count-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Same as <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn count(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_count1(
            self as *const crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Returns a pointer to the data stored in the vector. The pointer can be used to access and modify the items in the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair* QVector<QQmlContext::PropertyPair>::data()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#data">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a pointer to the data stored in the vector. The pointer can be used to access and modify the items in the vector.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span> vector(<span class="number">10</span>);
    ///   <span class="type">int</span> <span class="operator">*</span>data <span class="operator">=</span> vector<span class="operator">.</span>data();
    ///   <span class="keyword">for</span> (<span class="type">int</span> i <span class="operator">=</span> <span class="number">0</span>; i <span class="operator">&lt;</span> <span class="number">10</span>; <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     data<span class="operator">[</span>i<span class="operator">]</span> <span class="operator">=</span> <span class="number">2</span> <span class="operator">*</span> i;
    ///
    /// </pre>
    /// <p>The pointer remains valid as long as the vector isn't reallocated.</p>
    /// <p>This function is mostly useful to pass a vector to a function that accepts a plain C++ array.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#constData">constData</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn data_mut(&self) -> ::cpp_core::Ptr<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_data(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair* QVector<QQmlContext::PropertyPair>::data() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#data-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn data(&self) -> ::cpp_core::Ptr<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_data1(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
    }

    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::detach()```</span>.
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn detach(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_detach(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>(), returning <code>true</code> if the vector is empty; otherwise returns <code>false</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QVector<QQmlContext::PropertyPair>::empty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#empty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>(), returning <code>true</code> if the vector is empty; otherwise returns <code>false</code>.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_empty(
            self as *const crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Assigns <i>value</i> to all items in the vector. If <i>size</i> is different from -1 (the default), the vector is resized to size <i>size</i> beforehand.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>& QVector<QQmlContext::PropertyPair>::fill(const QQmlContext::PropertyPair& t, int size = …)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#fill">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns <i>value</i> to all items in the vector. If <i>size</i> is different from -1 (the default), the vector is resized to size <i>size</i> beforehand.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> vector(<span class="number">3</span>);
    ///   vector<span class="operator">.</span>fill(<span class="string">"Yes"</span>);
    ///   <span class="comment">// vector: ["Yes", "Yes", "Yes"]</span>
    ///
    ///   vector<span class="operator">.</span>fill(<span class="string">"oh"</span><span class="operator">,</span> <span class="number">5</span>);
    ///   <span class="comment">// vector: ["oh", "oh", "oh", "oh", "oh"]</span>
    ///
    /// </pre>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn fill_2a(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
        size: ::std::os::raw::c_int,
    ) -> ::cpp_core::Ref<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_fill(self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(t).as_raw_ptr(), size)
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Assigns <i>value</i> to all items in the vector. If <i>size</i> is different from -1 (the default), the vector is resized to size <i>size</i> beforehand.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>& QVector<QQmlContext::PropertyPair>::fill(const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#fill">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assigns <i>value</i> to all items in the vector. If <i>size</i> is different from -1 (the default), the vector is resized to size <i>size</i> beforehand.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> vector(<span class="number">3</span>);
    ///   vector<span class="operator">.</span>fill(<span class="string">"Yes"</span>);
    ///   <span class="comment">// vector: ["Yes", "Yes", "Yes"]</span>
    ///
    ///   vector<span class="operator">.</span>fill(<span class="string">"oh"</span><span class="operator">,</span> <span class="number">5</span>);
    ///   <span class="comment">// vector: ["oh", "oh", "oh", "oh", "oh"]</span>
    ///
    /// </pre>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn fill_1a(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) -> ::cpp_core::Ref<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_fill1(self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(t).as_raw_ptr())
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns a reference to the first item in the vector. This function assumes that the vector isn't empty.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::first()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#first">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the first item in the vector. This function assumes that the vector isn't empty.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#last">last</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#constFirst">constFirst</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn first_mut(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_first(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::first() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#first-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn first(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_first1(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#first">first</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::front()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#first">first</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn front_mut(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_front(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::front() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#front-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn front(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_front1(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Returns the item at index position <i>i</i> as a modifiable reference.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::operator[](int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the item at index position <i>i</i> as a modifiable reference.</p>
    /// <p><i>i</i> must be a valid index position in the vector (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>()).</p>
    /// <p>Note that using non-const operators can cause <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> to do a deep copy.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#value">value</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn index_mut(
        &self,
        i: ::std::os::raw::c_int,
    ) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator__2(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::operator[](int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Same as at(<i>i</i>).</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn index(
        &self,
        i: ::std::os::raw::c_int,
    ) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator__3(
                self as *const crate::QVectorOfPropertyPair,
                i,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Inserts <i>value</i> at index position <i>i</i> in the vector. If <i>i</i> is 0, the value is prepended to the vector. If <i>i</i> is <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>(), the value is appended to the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::insert(int i, const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#insert">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at index position <i>i</i> in the vector. If <i>i</i> is 0, the value is prepended to the vector. If <i>i</i> is <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>(), the value is appended to the vector.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> vector;
    ///   vector <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"alpha"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"beta"</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="string">"delta"</span>;
    ///   vector<span class="operator">.</span>insert(<span class="number">2</span><span class="operator">,</span> <span class="string">"gamma"</span>);
    ///   <span class="comment">// vector: ["alpha", "beta", "gamma", "delta"]</span>
    ///
    /// </pre>
    /// <p>For large vectors, this operation can be slow (<a href="http://doc.qt.io/qt-5/containers.html#linear-time">linear time</a>), because it requires moving all the items at indexes <i>i</i> and above by one position further in memory. If you want a container class that provides a fast insert() function, use <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> instead.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#prepend">prepend</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#remove">remove</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn insert_2a(
        &self,
        i: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_insert(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            i,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(
                t,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::insert(int i, int n, const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#insert-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Inserts <i>count</i> copies of <i>value</i> at index position <i>i</i> in the vector.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type">double</span><span class="operator">&gt;</span> vector;
    ///   vector <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="number">2.718</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="number">1.442</span> <span class="operator">&lt;</span><span class="operator">&lt;</span> <span class="number">0.4342</span>;
    ///   vector<span class="operator">.</span>insert(<span class="number">1</span><span class="operator">,</span> <span class="number">3</span><span class="operator">,</span> <span class="number">9.9</span>);
    ///   <span class="comment">// vector: [2.718, 9.9, 9.9, 9.9, 1.442, 0.4342]</span>
    ///
    /// </pre></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn insert_3a(
        &self,
        i: ::std::os::raw::c_int,
        n: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_insert1(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            i,
            n,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(
                t,
            )
            .as_raw_ptr(),
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QVector<QQmlContext::PropertyPair>::isDetached() const```</span>.
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn is_detached(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_isDetached(
            self as *const crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Returns <code>true</code> if the vector has size 0; otherwise returns <code>false</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QVector<QQmlContext::PropertyPair>::isEmpty() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the vector has size 0; otherwise returns <code>false</code>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn is_empty(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_isEmpty(
            self as *const crate::QVectorOfPropertyPair,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```bool QVector<QQmlContext::PropertyPair>::isSharedWith(const QVector<QQmlContext::PropertyPair>& other) const```</span>.
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn is_shared_with(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QVectorOfPropertyPair>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_isSharedWith(
            self as *const crate::QVectorOfPropertyPair,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QVectorOfPropertyPair>>::cast_into(other)
                .as_raw_ptr(),
        )
    }

    /// <p>Returns a reference to the last item in the vector. This function assumes that the vector isn't empty.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::last()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#last">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a reference to the last item in the vector. This function assumes that the vector isn't empty.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#first">first</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#constLast">constLast</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn last_mut(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_last(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair& QVector<QQmlContext::PropertyPair>::last() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#last-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn last(&self) -> ::cpp_core::Ref<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_last1(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
            .expect("attempted to construct a null Ref")
    }

    /// <p>Same as <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#count-1">count</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QVector<QQmlContext::PropertyPair>::length() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#length">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Same as <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#count-1">count</a>().</p>
    /// <p>Provided for compatibility with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p>This function was introduced in  Qt 5.2.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#count-1">count</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#length">QList::length</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn length(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_length(
            self as *const crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Returns a sub-vector which contains elements from this vector, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements after <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair> QVector<QQmlContext::PropertyPair>::mid(int pos, int len = …) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#mid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a sub-vector which contains elements from this vector, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements after <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn mid_2a(
        &self,
        pos: ::std::os::raw::c_int,
        len: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_mid(
                self as *const crate::QVectorOfPropertyPair,
                pos,
                len,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns a sub-vector which contains elements from this vector, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements after <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair> QVector<QQmlContext::PropertyPair>::mid(int pos) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#mid">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a sub-vector which contains elements from this vector, starting at position <i>pos</i>. If <i>length</i> is -1 (the default), all elements after <i>pos</i> are included; otherwise <i>length</i> elements (or all remaining elements if there are less than <i>length</i> elements) are included.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn mid_1a(
        &self,
        pos: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_mid1(
                self as *const crate::QVectorOfPropertyPair,
                pos,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Moves the item at index position <i>from</i> to index position <i>to</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::move(int from, int to)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#move">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Moves the item at index position <i>from</i> to index position <i>to</i>.</p>
    /// <p>Provided for compatibility with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p>This function was introduced in  Qt 5.6.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#move">QList::move</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn move_(&self, from: ::std::os::raw::c_int, to: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_move(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            from,
            to,
        )
    }

    /// <p>Constructs an empty vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QVector<QQmlContext::PropertyPair>::QVector()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#QVector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs an empty vector.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn new_0a() -> ::cpp_core::CppBox<crate::QVectorOfPropertyPair> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_QVector() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a vector with an initial size of <i>size</i> elements.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QVector<QQmlContext::PropertyPair>::QVector(int size)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#QVector-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a vector with an initial size of <i>size</i> elements.</p>
    /// <p>The elements are initialized with a <a href="http://doc.qt.io/qt-5/containers.html#default-constructed-value">default-constructed value</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn new_1a(
        size: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::QVectorOfPropertyPair> {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_QVector1(size) };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a vector with an initial size of <i>size</i> elements. Each element is initialized with <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QVector<QQmlContext::PropertyPair>::QVector(int size, const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#QVector-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a vector with an initial size of <i>size</i> elements. Each element is initialized with <i>value</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#fill">fill</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn new_2a(
        size: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) -> ::cpp_core::CppBox<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_QVector2(size, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(t).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a copy of <i>other</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QVector<QQmlContext::PropertyPair>::QVector(const QVector<QQmlContext::PropertyPair>& v)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#QVector-3">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a copy of <i>other</i>.</p>
    /// <p>This operation takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">constant time</a>, because <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> is <a href="http://doc.qt.io/qt-5/implicit-sharing.html">implicitly shared</a>. This makes returning a <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> from a function very fast. If a shared instance is modified, it will be copied (copy-on-write), and that takes <a href="http://doc.qt.io/qt-5/containers.html#algorithmic-complexity">linear time</a>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#operator-eq">operator=</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn new_copy(
        v: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QVectorOfPropertyPair>>,
    ) -> ::cpp_core::CppBox<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_QVector3(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QVectorOfPropertyPair>>::cast_into(v)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#removeLast">removeLast</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::pop_back()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#pop_back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#removeLast">removeLast</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn pop_back(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_pop_back(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#removeFirst">removeFirst</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::pop_front()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#pop_front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#removeFirst">removeFirst</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn pop_front(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_pop_front(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Inserts <i>value</i> at the beginning of the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::prepend(const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#prepend">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Inserts <i>value</i> at the beginning of the vector.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qstring.html">QString</a></span><span class="operator">&gt;</span> vector;
    ///   vector<span class="operator">.</span>prepend(<span class="string">"one"</span>);
    ///   vector<span class="operator">.</span>prepend(<span class="string">"two"</span>);
    ///   vector<span class="operator">.</span>prepend(<span class="string">"three"</span>);
    ///   <span class="comment">// vector: ["three", "two", "one"]</span>
    ///
    /// </pre>
    /// <p>This is the same as vector.insert(0, <i>value</i>).</p>
    /// <p>For large vectors, this operation can be slow (<a href="http://doc.qt.io/qt-5/containers.html#linear-time">linear time</a>), because it requires moving all the items in the vector by one position further in memory. If you want a container class that provides a fast prepend() function, use <a href="http://doc.qt.io/qt-5/qlist.html">QList</a> or <a href="http://doc.qt.io/qt-5/qlinkedlist.html">QLinkedList</a> instead.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#insert">insert</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn prepend(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_prepend(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(
                t,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to append(<i>value</i>).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::push_back(const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#push_back">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to append(<i>value</i>).</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn push_back(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_push_back(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(
                t,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to prepend(<i>value</i>).</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::push_front(const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#push_front">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to prepend(<i>value</i>).</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn push_front(
        &self,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_push_front(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(
                t,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::remove(int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#remove">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Removes the element at index position <i>i</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#insert">insert</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#replace">replace</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#fill">fill</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn remove_1a(&self, i: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_remove(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            i,
        )
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::remove(int i, int n)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#remove-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Removes <i>count</i> elements from the middle of the vector, starting at index position <i>i</i>.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#insert">insert</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#replace">replace</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#fill">fill</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn remove_2a(&self, i: ::std::os::raw::c_int, n: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_remove1(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            i,
            n,
        )
    }

    /// <p>Removes the element at index position <i>i</i>. Equivalent to</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::removeAt(int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#removeAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the element at index position <i>i</i>. Equivalent to</p>
    /// <pre class="cpp">
    ///
    ///   remove(i);
    ///
    /// </pre>
    /// <p>Provided for compatibility with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p>This function was introduced in  Qt 5.2.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#remove">remove</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#removeAt">QList::removeAt</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn remove_at(&self, i: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_removeAt(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            i,
        )
    }

    /// <p>Removes the first item in the vector. Calling this function is equivalent to calling remove(0). The vector must not be empty. If the vector can be empty, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::removeFirst()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#removeFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the first item in the vector. Calling this function is equivalent to calling remove(0). The vector must not be empty. If the vector can be empty, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>This function was introduced in  Qt 5.1.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#remove">remove</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#takeFirst">takeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn remove_first(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_removeFirst(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Removes the last item in the vector. Calling this function is equivalent to calling remove(<a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>() - 1). The vector must not be empty. If the vector can be empty, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::removeLast()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#removeLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the last item in the vector. Calling this function is equivalent to calling remove(<a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>() - 1). The vector must not be empty. If the vector can be empty, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>This function was introduced in  Qt 5.1.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#remove">remove</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#takeLast">takeLast</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#removeFirst">removeFirst</a>(), and <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn remove_last(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_removeLast(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Replaces the item at index position <i>i</i> with <i>value</i>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::replace(int i, const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#replace">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Replaces the item at index position <i>i</i> with <i>value</i>.</p>
    /// <p><i>i</i> must be a valid index position in the vector (i.e., 0 &lt;= <i>i</i> &lt; <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>()).</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d">operator[]</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#remove">remove</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn replace(
        &self,
        i: ::std::os::raw::c_int,
        t: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_replace(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            i,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(
                t,
            )
            .as_raw_ptr(),
        )
    }

    /// <p>Attempts to allocate memory for at least <i>size</i> elements. If you know in advance how large the vector will be, you should call this function to prevent reallocations and memory fragmentation.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::reserve(int size)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#reserve">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Attempts to allocate memory for at least <i>size</i> elements. If you know in advance how large the vector will be, you should call this function to prevent reallocations and memory fragmentation.</p>
    /// <p>If <i>size</i> is an underestimate, the worst that will happen is that the <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> will be a bit slower. If <i>size</i> is an overestimate, you may have used more memory than the normal <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a> growth strategy would have allocated—or you may have used less.</p>
    /// <p>An alternative to reserve() is calling <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>(). Whether or not that is faster than reserve() depends on the element type, because <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>() default-constructs all elements, and requires assignment to existing entries rather than calling <a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>(), which copy- or move-constructs. For simple types, like <code>int</code> or <code>double</code>, <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>() is typically faster, but for anything more complex, you should prefer reserve().</p>
    /// <p><b>Warning:</b> If the size passed to <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>() was underestimated, you run out of allocated space and into undefined behavior. This problem does not exist with reserve(), because it treats the size as just a hint.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#squeeze">squeeze</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#capacity">capacity</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn reserve(&self, size: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_reserve(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            size,
        )
    }

    /// <p>Sets the size of the vector to <i>size</i>. If <i>size</i> is greater than the current size, elements are added to the end; the new elements are initialized with a <a href="http://doc.qt.io/qt-5/containers.html#default-constructed-value">default-constructed value</a>. If <i>size</i> is less than the current size, elements are removed from the end.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::resize(int size)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#resize">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Sets the size of the vector to <i>size</i>. If <i>size</i> is greater than the current size, elements are added to the end; the new elements are initialized with a <a href="http://doc.qt.io/qt-5/containers.html#default-constructed-value">default-constructed value</a>. If <i>size</i> is less than the current size, elements are removed from the end.</p>
    /// <p>Since Qt 5.6, resize() doesn't shrink the capacity anymore. To shed excess capacity, use <a href="http://doc.qt.io/qt-5/qvector.html#squeeze">squeeze</a>().</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn resize(&self, size: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_resize(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            size,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::setSharable(bool sharable)```</span>.
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn set_sharable(&self, sharable: bool) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_setSharable(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            sharable,
        )
    }

    /// <p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#squeeze">squeeze</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::shrink_to_fit()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#shrink_to_fit">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function is provided for STL compatibility. It is equivalent to <a href="http://doc.qt.io/qt-5/qvector.html#squeeze">squeeze</a>().</p>
    /// <p>This function was introduced in  Qt 5.10.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn shrink_to_fit(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_shrink_to_fit(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Returns the number of items in the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QVector<QQmlContext::PropertyPair>::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the vector.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn size(&self) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_size(
            self as *const crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Releases any memory not required to store the items.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::squeeze()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#squeeze">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Releases any memory not required to store the items.</p>
    /// <p>The sole purpose of this function is to provide a means of fine tuning <a href="http://doc.qt.io/qt-5/qvector.html">QVector</a>'s memory usage. In general, you will rarely ever need to call this function.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#reserve">reserve</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#capacity">capacity</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn squeeze(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_squeeze(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Swaps vector <i>other</i> with this vector. This operation is very fast and never fails.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::swap(QVector<QQmlContext::PropertyPair>& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#swap">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Swaps vector <i>other</i> with this vector. This operation is very fast and never fails.</p>
    /// <p>This function was introduced in  Qt 4.8.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn swap(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QVectorOfPropertyPair>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_swap(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QVectorOfPropertyPair>>::cast_into(other)
                .as_raw_ptr() as *mut crate::QVectorOfPropertyPair,
        )
    }

    /// <p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>().</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QVector<QQmlContext::PropertyPair>::swapItemsAt(int i, int j)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#swapItemsAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Exchange the item at index position <i>i</i> with the item at index position <i>j</i>. This function assumes that both <i>i</i> and <i>j</i> are at least 0 but less than <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>(). To avoid failure, test that both <i>i</i> and <i>j</i> are at least 0 and less than <a href="http://doc.qt.io/qt-5/qvector.html#size">size</a>().</p>
    /// <p>This function was introduced in  Qt 5.14.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(cpp_lib_version = "5.14.0"))
    )]
    #[cfg(any(cpp_lib_version = "5.14.0", feature = "ritual_rustdoc"))]
    pub unsafe fn swap_items_at(&self, i: ::std::os::raw::c_int, j: ::std::os::raw::c_int) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_swapItemsAt(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            i,
            j,
        )
    }

    /// <p>Removes the element at index position <i>i</i> and returns it.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair QVector<QQmlContext::PropertyPair>::takeAt(int i)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#takeAt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the element at index position <i>i</i> and returns it.</p>
    /// <p>Equivalent to</p>
    /// <pre class="cpp">
    ///
    ///   T t <span class="operator">=</span> at(i);
    ///   remove(i);
    ///   <span class="keyword">return</span> t;
    ///
    /// </pre>
    /// <p>Provided for compatibility with <a href="http://doc.qt.io/qt-5/qlist.html">QList</a>.</p>
    /// <p>This function was introduced in  Qt 5.2.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#takeFirst">takeFirst</a>(), <a href="http://doc.qt.io/qt-5/qvector.html#takeLast">takeLast</a>(), and <a href="http://doc.qt.io/qt-5/qlist.html#takeAt">QList::takeAt</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn take_at(
        &self,
        i: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_takeAt(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
                i,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the first item in the vector and returns it. This function assumes the vector is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair QVector<QQmlContext::PropertyPair>::takeFirst()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#takeFirst">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the first item in the vector and returns it. This function assumes the vector is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>This function was introduced in  Qt 5.1.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#takeLast">takeLast</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#removeFirst">removeFirst</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn take_first(&self) -> ::cpp_core::CppBox<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_takeFirst(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Removes the last item in the list and returns it. This function assumes the vector is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair QVector<QQmlContext::PropertyPair>::takeLast()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#takeLast">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Removes the last item in the list and returns it. This function assumes the vector is not empty. To avoid failure, call <a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() before calling this function.</p>
    /// <p>If you don't use the return value, <a href="http://doc.qt.io/qt-5/qvector.html#removeLast">removeLast</a>() is more efficient.</p>
    /// <p>This function was introduced in  Qt 5.1.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#takeFirst">takeFirst</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#removeLast">removeLast</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn take_last(&self) -> ::cpp_core::CppBox<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_takeLast(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Returns the value at index position <i>i</i> in the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair QVector<QQmlContext::PropertyPair>::value(int i) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#value">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the value at index position <i>i</i> in the vector.</p>
    /// <p>If the index <i>i</i> is out of bounds, the function returns a <a href="http://doc.qt.io/qt-5/containers.html#default-constructed-value">default-constructed value</a>. If you are certain that <i>i</i> is within bounds, you can use <a href="http://doc.qt.io/qt-5/qvector.html#at">at</a>() instead, which is slightly faster.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#at">at</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn value_1a(
        &self,
        i: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_value(
                self as *const crate::QVectorOfPropertyPair,
                i,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair QVector<QQmlContext::PropertyPair>::value(int i, const QQmlContext::PropertyPair& defaultValue) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#value-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>If the index <i>i</i> is out of bounds, the function returns <i>defaultValue</i>.</p></div>
    #[inline(always)]
    #[cfg_attr(
        feature = "ritual_rustdoc_nightly",
        doc(cfg(any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        )))
    )]
    #[cfg(any(
        any(
            cpp_lib_version = "5.13.0",
            cpp_lib_version = "5.11.3",
            cpp_lib_version = "5.12.2",
            cpp_lib_version = "5.14.0"
        ),
        feature = "ritual_rustdoc"
    ))]
    pub unsafe fn value_2a(
        &self,
        i: ::std::os::raw::c_int,
        default_value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>,
    ) -> ::cpp_core::CppBox<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_value1(self as *const crate::QVectorOfPropertyPair, i, ::cpp_core::CastInto::<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>::cast_into(default_value).as_raw_ptr())
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

/// <p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
///
/// C++ class: <span style='color: green;'>```QPointer<QObject>```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qpointer.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
/// <p>A guarded pointer, <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;T&gt;, behaves like a normal C++ pointer <code>T *</code>, except that it is automatically set to 0 when the referenced object is destroyed (unlike normal C++ pointers, which become "dangling pointers" in such cases). <code>T</code> must be a subclass of <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
/// <p>Guarded pointers are useful whenever you need to store a pointer to a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> that is owned by someone else, and therefore might be destroyed while you still hold a reference to it. You can safely test the pointer for validity.</p>
/// <p>Note that Qt 5 introduces a slight change in behavior when using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>.</p>
/// <ul>
/// <li>When using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> on a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> (or a subclass of <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>), previously the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> would be cleared by the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor. Now, the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> is cleared by the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> destructor (since this is when <a href="http://doc.qt.io/qt-5/qweakpointer.html">QWeakPointer</a> objects are cleared). Any QPointers tracking a widget will <b>NOT</b> be cleared before the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor destroys the children for the widget being tracked.</li>
/// </ul>
/// <p>Qt also provides <a href="http://doc.qt.io/qt-5/qsharedpointer.html">QSharedPointer</a>, an implementation of a reference-counted shared pointer object, which can be used to maintain a collection of references to an individual pointer.</p>
/// <p>Example:</p>
/// <pre class="cpp">
///
/// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qpointer.html#QPointer">QPointer</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span><span class="operator">&gt;</span> label <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span>;
/// &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>setText(<span class="string">"&amp;Status:"</span>);
/// &#32;     ...
/// &#32;     <span class="keyword">if</span> (label)
/// &#32;   &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>show();
///
/// </pre>
/// <p>If the <a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a> is deleted in the meantime, the <code>label</code> variable will hold 0 instead of an invalid address, and the last line will never be executed.</p>
/// <p>The functions and operators available with a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> are the same as those available with a normal unguarded pointer, except the pointer arithmetic operators (<code>+</code>, <code>-</code>, <code>++</code>, and <code>--</code>), which are normally used only with arrays of objects.</p>
/// <p>Use QPointers like normal pointers and you will not need to read this class documentation.</p>
/// <p>For creating guarded pointers, you can construct or assign to them from a T* or from another guarded pointer of the same type. You can compare them with each other using operator==() and operator!=(), or test for 0 with <a href="http://doc.qt.io/qt-5/qpointer.html#isNull">isNull</a>(). You can dereference them using either the <code>*x</code> or the <code>x-&gt;member</code> notation.</p>
/// <p>A guarded pointer will automatically cast to a <code>T</code> *, so you can freely mix guarded and unguarded pointers. This means that if you have a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>&gt;, you can pass it to a function that requires a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *. For this reason, it is of little value to declare functions to take a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> as a parameter; just use normal pointers. Use a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> when you are storing a pointer over time.</p>
/// <p>Note that class <code>T</code> must inherit <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, or a compilation or link error will result.</p></div>
#[repr(C)]
pub struct QPointerOfQObject {
    _unused: u8,
}
impl QPointerOfQObject {
    /// <p>Clears this <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QPointer<QObject>::clear()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#clear">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Clears this <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> object.</p>
    /// <p>This function was introduced in  Qt 5.0.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qpointer.html#isNull">isNull</a>().</p></div>
    #[inline(always)]
    pub unsafe fn clear(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_clear(
            self as *const crate::QPointerOfQObject as *mut crate::QPointerOfQObject,
        )
    }

    /// <p>Assignment operator. This guarded pointer will now point to the same object that <i>p</i> points to.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QPointer<QObject>& QPointer<QObject>::operator=(QObject* p)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#operator-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Assignment operator. This guarded pointer will now point to the same object that <i>p</i> points to.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from_q_object(
        &self,
        p: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::cpp_core::Ref<crate::QPointerOfQObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_operator_(
                self as *const crate::QPointerOfQObject as *mut crate::QPointerOfQObject,
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(p)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QPointer<QObject>& QPointer<QObject>::operator=(const QPointer<QObject>& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    /// <p>A guarded pointer, <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;T&gt;, behaves like a normal C++ pointer <code>T *</code>, except that it is automatically set to 0 when the referenced object is destroyed (unlike normal C++ pointers, which become "dangling pointers" in such cases). <code>T</code> must be a subclass of <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    /// <p>Guarded pointers are useful whenever you need to store a pointer to a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> that is owned by someone else, and therefore might be destroyed while you still hold a reference to it. You can safely test the pointer for validity.</p>
    /// <p>Note that Qt 5 introduces a slight change in behavior when using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>.</p>
    /// <ul>
    /// <li>When using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> on a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> (or a subclass of <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>), previously the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> would be cleared by the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor. Now, the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> is cleared by the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> destructor (since this is when <a href="http://doc.qt.io/qt-5/qweakpointer.html">QWeakPointer</a> objects are cleared). Any QPointers tracking a widget will <b>NOT</b> be cleared before the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor destroys the children for the widget being tracked.</li>
    /// </ul>
    /// <p>Qt also provides <a href="http://doc.qt.io/qt-5/qsharedpointer.html">QSharedPointer</a>, an implementation of a reference-counted shared pointer object, which can be used to maintain a collection of references to an individual pointer.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qpointer.html#QPointer">QPointer</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span><span class="operator">&gt;</span> label <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span>;
    /// &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>setText(<span class="string">"&amp;Status:"</span>);
    /// &#32;     ...
    /// &#32;     <span class="keyword">if</span> (label)
    /// &#32;   &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>show();
    ///
    /// </pre>
    /// <p>If the <a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a> is deleted in the meantime, the <code>label</code> variable will hold 0 instead of an invalid address, and the last line will never be executed.</p>
    /// <p>The functions and operators available with a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> are the same as those available with a normal unguarded pointer, except the pointer arithmetic operators (<code>+</code>, <code>-</code>, <code>++</code>, and <code>--</code>), which are normally used only with arrays of objects.</p>
    /// <p>Use QPointers like normal pointers and you will not need to read this class documentation.</p>
    /// <p>For creating guarded pointers, you can construct or assign to them from a T* or from another guarded pointer of the same type. You can compare them with each other using operator==() and operator!=(), or test for 0 with <a href="http://doc.qt.io/qt-5/qpointer.html#isNull">isNull</a>(). You can dereference them using either the <code>*x</code> or the <code>x-&gt;member</code> notation.</p>
    /// <p>A guarded pointer will automatically cast to a <code>T</code> *, so you can freely mix guarded and unguarded pointers. This means that if you have a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>&gt;, you can pass it to a function that requires a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *. For this reason, it is of little value to declare functions to take a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> as a parameter; just use normal pointers. Use a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> when you are storing a pointer over time.</p>
    /// <p>Note that class <code>T</code> must inherit <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, or a compilation or link error will result.</p></div>
    #[inline(always)]
    pub unsafe fn copy_from_q_pointer_of_q_object(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QPointerOfQObject>>,
    ) -> ::cpp_core::Ref<crate::QPointerOfQObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_operator_2(
                self as *const crate::QPointerOfQObject as *mut crate::QPointerOfQObject,
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QPointerOfQObject>>::cast_into(other)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns the pointer to the object being guarded.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QPointer<QObject>::data() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#data">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the pointer to the object being guarded.</p>
    /// <p>This function was introduced in  Qt 4.4.</p></div>
    #[inline(always)]
    pub unsafe fn data(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_data(
                self as *const crate::QPointerOfQObject,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Returns <code>true</code> if <i>c1</i> and <i>c2</i> are the same Unicode character; otherwise returns <code>false</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool operator==(const QPointer<QObject>& p, QObject* o)```</span>.
    ///
    /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qchar.html#operator-eq-eq">C++ documentation</a> for <span style='color: green;'>```bool operator==(QChar c1, QChar c2)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>c1</i> and <i>c2</i> are the same Unicode character; otherwise returns <code>false</code>.</p></div>
    #[inline(always)]
    pub unsafe fn eq(
        &self,
        o: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_operator__47(
            self as *const crate::QPointerOfQObject,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(o).as_raw_ptr()
                as *mut ::qt_core::QObject,
        )
    }

    /// <p>Dereference operator; implements pointer semantics. Just use this operator as you would with a normal C++ pointer.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject& QPointer<QObject>::operator*() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Dereference operator; implements pointer semantics. Just use this operator as you would with a normal C++ pointer.</p></div>
    #[inline(always)]
    pub unsafe fn indirection(&self) -> ::cpp_core::Ref<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_operator_1(
                self as *const crate::QPointerOfQObject,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }

    /// <p>Returns <code>true</code> if the referenced object has been destroyed or if there is no referenced object; otherwise returns <code>false</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QPointer<QObject>::isNull() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#isNull">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if the referenced object has been destroyed or if there is no referenced object; otherwise returns <code>false</code>.</p></div>
    #[inline(always)]
    pub unsafe fn is_null(&self) -> bool {
        crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_isNull(
            self as *const crate::QPointerOfQObject,
        )
    }

    /// <p>Constructs a 0 guarded pointer.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QPointer<QObject>::QPointer()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#QPointer">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a 0 guarded pointer.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qpointer.html#isNull">isNull</a>().</p></div>
    #[inline(always)]
    pub unsafe fn new_0a() -> ::cpp_core::CppBox<crate::QPointerOfQObject> {
        let ffi_result = { crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_QPointer() };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Constructs a guarded pointer that points to the same object that <i>p</i> points to.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QPointer<QObject>::QPointer(QObject* p)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#QPointer-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Constructs a guarded pointer that points to the same object that <i>p</i> points to.</p></div>
    #[inline(always)]
    pub unsafe fn new_1a(
        p: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
    ) -> ::cpp_core::CppBox<crate::QPointerOfQObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_QPointer1(
                ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(p)
                    .as_raw_ptr() as *mut ::qt_core::QObject,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[constructor] void QPointer<QObject>::QPointer(const QPointer<QObject>& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    /// <p>A guarded pointer, <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;T&gt;, behaves like a normal C++ pointer <code>T *</code>, except that it is automatically set to 0 when the referenced object is destroyed (unlike normal C++ pointers, which become "dangling pointers" in such cases). <code>T</code> must be a subclass of <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    /// <p>Guarded pointers are useful whenever you need to store a pointer to a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> that is owned by someone else, and therefore might be destroyed while you still hold a reference to it. You can safely test the pointer for validity.</p>
    /// <p>Note that Qt 5 introduces a slight change in behavior when using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>.</p>
    /// <ul>
    /// <li>When using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> on a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> (or a subclass of <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>), previously the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> would be cleared by the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor. Now, the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> is cleared by the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> destructor (since this is when <a href="http://doc.qt.io/qt-5/qweakpointer.html">QWeakPointer</a> objects are cleared). Any QPointers tracking a widget will <b>NOT</b> be cleared before the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor destroys the children for the widget being tracked.</li>
    /// </ul>
    /// <p>Qt also provides <a href="http://doc.qt.io/qt-5/qsharedpointer.html">QSharedPointer</a>, an implementation of a reference-counted shared pointer object, which can be used to maintain a collection of references to an individual pointer.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qpointer.html#QPointer">QPointer</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span><span class="operator">&gt;</span> label <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span>;
    /// &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>setText(<span class="string">"&amp;Status:"</span>);
    /// &#32;     ...
    /// &#32;     <span class="keyword">if</span> (label)
    /// &#32;   &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>show();
    ///
    /// </pre>
    /// <p>If the <a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a> is deleted in the meantime, the <code>label</code> variable will hold 0 instead of an invalid address, and the last line will never be executed.</p>
    /// <p>The functions and operators available with a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> are the same as those available with a normal unguarded pointer, except the pointer arithmetic operators (<code>+</code>, <code>-</code>, <code>++</code>, and <code>--</code>), which are normally used only with arrays of objects.</p>
    /// <p>Use QPointers like normal pointers and you will not need to read this class documentation.</p>
    /// <p>For creating guarded pointers, you can construct or assign to them from a T* or from another guarded pointer of the same type. You can compare them with each other using operator==() and operator!=(), or test for 0 with <a href="http://doc.qt.io/qt-5/qpointer.html#isNull">isNull</a>(). You can dereference them using either the <code>*x</code> or the <code>x-&gt;member</code> notation.</p>
    /// <p>A guarded pointer will automatically cast to a <code>T</code> *, so you can freely mix guarded and unguarded pointers. This means that if you have a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>&gt;, you can pass it to a function that requires a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *. For this reason, it is of little value to declare functions to take a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> as a parameter; just use normal pointers. Use a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> when you are storing a pointer over time.</p>
    /// <p>Note that class <code>T</code> must inherit <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, or a compilation or link error will result.</p></div>
    #[inline(always)]
    pub unsafe fn new_copy(
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QPointerOfQObject>>,
    ) -> ::cpp_core::CppBox<crate::QPointerOfQObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_QPointer2(
                ::cpp_core::CastInto::<::cpp_core::Ref<crate::QPointerOfQObject>>::cast_into(other)
                    .as_raw_ptr(),
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    /// <p>Overloaded arrow operator; implements pointer semantics. Just use this operator as you would with a normal C++ pointer.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QPointer<QObject>::operator->() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#operator--gt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Overloaded arrow operator; implements pointer semantics. Just use this operator as you would with a normal C++ pointer.</p></div>
    #[inline(always)]
    pub unsafe fn struct_deref(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_operator__(
                self as *const crate::QPointerOfQObject,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }

    /// <p>Swaps the contents of this <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> with the contents of <i>other</i>. This operation is very fast and never fails.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```void QPointer<QObject>::swap(QPointer<QObject>& other)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#swap">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Swaps the contents of this <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> with the contents of <i>other</i>. This operation is very fast and never fails.</p>
    /// <p>This function was introduced in  Qt 5.6.</p></div>
    #[inline(always)]
    pub unsafe fn swap(
        &self,
        other: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QPointerOfQObject>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_swap(
            self as *const crate::QPointerOfQObject as *mut crate::QPointerOfQObject,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QPointerOfQObject>>::cast_into(other)
                .as_raw_ptr() as *mut crate::QPointerOfQObject,
        )
    }

    /// Calls C++ function: <span style='color: green;'>```QObject* QPointer<QObject>::operator QObject*() const```</span>.
    #[inline(always)]
    pub unsafe fn to_q_ptr_q_object(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_operator_QObject_(
                self as *const crate::QPointerOfQObject,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }
}

impl ::qt_core::AsReceiver for crate::SignalOfQStringQVariant {
    type Arguments = (*const ::qt_core::QString, *const ::qt_core::QVariant);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2emit_(QString const &,QVariant const &)\0",
                ),
            )
        }
    }
}

impl crate::SignalOfQStringQVariant {
    /// Connects this signal to another signal or slot.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect_with_type<R>(
        &self,
        connection_type: ::qt_core::ConnectionType,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (*const ::qt_core::QString, *const ::qt_core::QVariant):
            ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect_with_type(connection_type, receiver)
    }

    /// Connects this signal to another signal or slot, using auto connection type.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect<R>(
        &self,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (*const ::qt_core::QString, *const ::qt_core::QVariant):
            ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect(receiver)
    }
}

/// Emits a Qt signal with arguments `*const ::qt_core::QString,*const ::qt_core::QVariant`.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```const QString&, const QVariant&```</span>).
///
/// Use `connect()` method of this object to connect this signal to a slot. Use `emit()` method to emit the signal.
#[repr(C)]
pub struct SignalOfQStringQVariant {
    _unused: u8,
}
impl SignalOfQStringQVariant {
    /// Returns a `Signal` object representing the signal.
    ///
    /// This method is useful if you need to connect another signal to this signal. However, when you need to connect this signal to another signal or slot, it's simpler to use the `connect()` method of this object directly.
    #[inline(always)]
    pub fn signal(
        &self,
    ) -> ::qt_core::Signal<(*const ::qt_core::QString, *const ::qt_core::QVariant)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2emit_(QString const &,QVariant const &)\0",
                ),
            )
        }
    }

    /// Emits the signal.
    #[inline(always)]
    pub unsafe fn emit(
        &self,
        arg0: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_emit_(self as *const crate::SignalOfQStringQVariant as *mut crate::SignalOfQStringQVariant, ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg0).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(arg1).as_raw_ptr())
    }

    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_metaObject(self as *const crate::SignalOfQStringQVariant)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new() -> ::qt_core::QBox<crate::SignalOfQStringQVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref()
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_qt_metacall(self as *const crate::SignalOfQStringQVariant as *mut crate::SignalOfQStringQVariant, arg1, arg2, arg3)
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_qt_metacast(self as *const crate::SignalOfQStringQVariant as *mut crate::SignalOfQStringQVariant, arg1)
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_tr(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_trUtf8(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::qt_core::AsReceiver for crate::SignalOfStatus {
    type Arguments = (crate::q_qml_component::Status,);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"2emit_(QQmlComponent::Status)\0"),
            )
        }
    }
}

impl crate::SignalOfStatus {
    /// Connects this signal to another signal or slot.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect_with_type<R>(
        &self,
        connection_type: ::qt_core::ConnectionType,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (crate::q_qml_component::Status,): ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect_with_type(connection_type, receiver)
    }

    /// Connects this signal to another signal or slot, using auto connection type.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect<R>(
        &self,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (crate::q_qml_component::Status,): ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect(receiver)
    }
}

/// Emits a Qt signal with arguments `crate::q_qml_component::Status`.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```QQmlComponent::Status```</span>).
///
/// Use `connect()` method of this object to connect this signal to a slot. Use `emit()` method to emit the signal.
#[repr(C)]
pub struct SignalOfStatus {
    _unused: u8,
}
impl SignalOfStatus {
    /// Returns a `Signal` object representing the signal.
    ///
    /// This method is useful if you need to connect another signal to this signal. However, when you need to connect this signal to another signal or slot, it's simpler to use the `connect()` method of this object directly.
    #[inline(always)]
    pub fn signal(&self) -> ::qt_core::Signal<(crate::q_qml_component::Status,)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"2emit_(QQmlComponent::Status)\0"),
            )
        }
    }

    /// Emits the signal.
    #[inline(always)]
    pub unsafe fn emit(&self, arg0: crate::q_qml_component::Status) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_emit_(
            self as *const crate::SignalOfStatus as *mut crate::SignalOfStatus,
            arg0,
        )
    }

    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_metaObject(self as *const crate::SignalOfStatus)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new() -> ::qt_core::QBox<crate::SignalOfStatus> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status()
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_qt_metacall(
            self as *const crate::SignalOfStatus as *mut crate::SignalOfStatus,
            arg1,
            arg2,
            arg3,
        )
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_qt_metacast(
            self as *const crate::SignalOfStatus as *mut crate::SignalOfStatus,
            arg1,
        )
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_tr(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_trUtf8(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::qt_core::AsReceiver for crate::SignalOfQListOfQQmlError {
    type Arguments = (*const crate::QListOfQQmlError,);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2emit_(QList< QQmlError > const &)\0",
                ),
            )
        }
    }
}

impl crate::SignalOfQListOfQQmlError {
    /// Connects this signal to another signal or slot.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect_with_type<R>(
        &self,
        connection_type: ::qt_core::ConnectionType,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (*const crate::QListOfQQmlError,): ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect_with_type(connection_type, receiver)
    }

    /// Connects this signal to another signal or slot, using auto connection type.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect<R>(
        &self,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (*const crate::QListOfQQmlError,): ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect(receiver)
    }
}

/// Emits a Qt signal with arguments `*const crate::QListOfQQmlError`.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```const QList<QQmlError>&```</span>).
///
/// Use `connect()` method of this object to connect this signal to a slot. Use `emit()` method to emit the signal.
#[repr(C)]
pub struct SignalOfQListOfQQmlError {
    _unused: u8,
}
impl SignalOfQListOfQQmlError {
    /// Returns a `Signal` object representing the signal.
    ///
    /// This method is useful if you need to connect another signal to this signal. However, when you need to connect this signal to another signal or slot, it's simpler to use the `connect()` method of this object directly.
    #[inline(always)]
    pub fn signal(&self) -> ::qt_core::Signal<(*const crate::QListOfQQmlError,)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2emit_(QList< QQmlError > const &)\0",
                ),
            )
        }
    }

    /// Emits the signal.
    #[inline(always)]
    pub unsafe fn emit(
        &self,
        arg0: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_emit_(
            self as *const crate::SignalOfQListOfQQmlError as *mut crate::SignalOfQListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(arg0)
                .as_raw_ptr(),
        )
    }

    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_metaObject(self as *const crate::SignalOfQListOfQQmlError)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new() -> ::qt_core::QBox<crate::SignalOfQListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref()
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_qt_metacall(self as *const crate::SignalOfQListOfQQmlError as *mut crate::SignalOfQListOfQQmlError, arg1, arg2, arg3)
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_qt_metacast(self as *const crate::SignalOfQListOfQQmlError as *mut crate::SignalOfQListOfQQmlError, arg1)
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_tr(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_trUtf8(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::qt_core::AsReceiver for crate::SignalOfQObjectQUrl {
    type Arguments = (*mut ::qt_core::QObject, *const ::qt_core::QUrl);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2emit_(QObject *,QUrl const &)\0",
                ),
            )
        }
    }
}

impl crate::SignalOfQObjectQUrl {
    /// Connects this signal to another signal or slot.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect_with_type<R>(
        &self,
        connection_type: ::qt_core::ConnectionType,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (*mut ::qt_core::QObject, *const ::qt_core::QUrl):
            ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect_with_type(connection_type, receiver)
    }

    /// Connects this signal to another signal or slot, using auto connection type.
    ///
    /// This is a shortcut for `self.signal().connect(receiver)`.

    pub unsafe fn connect<R>(
        &self,
        receiver: R,
    ) -> cpp_core::CppBox<::qt_core::q_meta_object::Connection>
    where
        R: ::qt_core::AsReceiver,
        (*mut ::qt_core::QObject, *const ::qt_core::QUrl):
            ::qt_core::ArgumentsCompatible<R::Arguments>,
    {
        self.signal().connect(receiver)
    }
}

/// Emits a Qt signal with arguments `*mut ::qt_core::QObject,*const ::qt_core::QUrl`.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```QObject*, const QUrl&```</span>).
///
/// Use `connect()` method of this object to connect this signal to a slot. Use `emit()` method to emit the signal.
#[repr(C)]
pub struct SignalOfQObjectQUrl {
    _unused: u8,
}
impl SignalOfQObjectQUrl {
    /// Returns a `Signal` object representing the signal.
    ///
    /// This method is useful if you need to connect another signal to this signal. However, when you need to connect this signal to another signal or slot, it's simpler to use the `connect()` method of this object directly.
    #[inline(always)]
    pub fn signal(&self) -> ::qt_core::Signal<(*mut ::qt_core::QObject, *const ::qt_core::QUrl)> {
        unsafe {
            ::qt_core::Signal::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"2emit_(QObject *,QUrl const &)\0",
                ),
            )
        }
    }

    /// Emits the signal.
    #[inline(always)]
    pub unsafe fn emit(
        &self,
        arg0: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_emit_(
            self as *const crate::SignalOfQObjectQUrl as *mut crate::SignalOfQObjectQUrl,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg0)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg1).as_raw_ptr(),
        )
    }

    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_metaObject(self as *const crate::SignalOfQObjectQUrl)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new() -> ::qt_core::QBox<crate::SignalOfQObjectQUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref()
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_qt_metacall(self as *const crate::SignalOfQObjectQUrl as *mut crate::SignalOfQObjectQUrl, arg1, arg2, arg3)
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_qt_metacast(self as *const crate::SignalOfQObjectQUrl as *mut crate::SignalOfQObjectQUrl, arg1)
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_tr(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_trUtf8(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::qt_core::AsReceiver for crate::SlotOfQObjectQUrl {
    type Arguments = (*mut ::qt_core::QObject, *const ::qt_core::QUrl);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"1slot_(QObject *,QUrl const &)\0",
                ),
            )
        }
    }
}

/// Binds a Qt signal with arguments `*mut ::qt_core::QObject,*const ::qt_core::QUrl` to a Rust closure.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```QObject*, const QUrl&```</span>).
///
/// Create an object using `new()` and bind your closure using `set()`. The closure will be called with the signal's arguments when the slot is invoked. Use `connect()` method of a `qt_core::Signal` object to connect the signal to this slot. The closure will be executed each time the slot is invoked until source signals are disconnected or the slot object is destroyed.
///
/// The slot object takes ownership of the passed closure. If `set()` is called again, previously set closure is dropped. Make sure that the slot object does not outlive objects referenced by the closure.
///
/// If `set()` was not called, slot invocation has no effect.
#[repr(C)]
pub struct SlotOfQObjectQUrl {
    _unused: u8,
}
impl SlotOfQObjectQUrl {
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_metaObject(self as *const crate::SlotOfQObjectQUrl)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new<
        T: FnMut(::qt_core::QPtr<::qt_core::QObject>, ::cpp_core::Ref<::qt_core::QUrl>) + 'static,
    >(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        callback: T,
    ) -> ::qt_core::QBox<crate::SlotOfQObjectQUrl> {
        let ffi_result = {
            extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
                unsafe {
                    let _ = Box::from_raw(data as *mut T);
                }
            }
            extern "C" fn ffi_callback<
                T: FnMut(::qt_core::QPtr<::qt_core::QObject>, ::cpp_core::Ref<::qt_core::QUrl>)
                    + 'static,
            >(
                data: *mut ::std::ffi::c_void,
                arg0: *mut ::qt_core::QObject,
                arg1: *const ::qt_core::QUrl,
            ) {
                unsafe {
                    (*(data as *mut T))(
                        ::qt_core::QPtr::from_raw(arg0),
                        ::cpp_core::Ref::from_raw(arg1 as *mut ::qt_core::QUrl)
                            .expect("attempted to construct a null Ref"),
                    )
                }
            }
            let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref(::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent).as_raw_ptr() as *mut ::qt_core::QObject, Some(ffi_callback::<T>), Some(deleter::<T>), data)
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_qt_metacall(self as *const crate::SlotOfQObjectQUrl as *mut crate::SlotOfQObjectQUrl, arg1, arg2, arg3)
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_qt_metacast(self as *const crate::SlotOfQObjectQUrl as *mut crate::SlotOfQObjectQUrl, arg1)
    }

    /// Assigns `callback` as the signal handler.
    ///
    /// `func` will be called each time a connected signal is emitted. Any previously assigned function will be deregistered. Passing `None` will deregister the handler without setting a new one.
    #[inline(always)]
    pub unsafe fn set<
        T: FnMut(::qt_core::QPtr<::qt_core::QObject>, ::cpp_core::Ref<::qt_core::QUrl>) + 'static,
    >(
        &self,
        callback: T,
    ) {
        extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
            unsafe {
                let _ = Box::from_raw(data as *mut T);
            }
        }
        extern "C" fn ffi_callback<
            T: FnMut(::qt_core::QPtr<::qt_core::QObject>, ::cpp_core::Ref<::qt_core::QUrl>) + 'static,
        >(
            data: *mut ::std::ffi::c_void,
            arg0: *mut ::qt_core::QObject,
            arg1: *const ::qt_core::QUrl,
        ) {
            unsafe {
                (*(data as *mut T))(
                    ::qt_core::QPtr::from_raw(arg0),
                    ::cpp_core::Ref::from_raw(arg1 as *mut ::qt_core::QUrl)
                        .expect("attempted to construct a null Ref"),
                )
            }
        }
        let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_set(
            self as *const crate::SlotOfQObjectQUrl as *mut crate::SlotOfQObjectQUrl,
            Some(ffi_callback::<T>),
            Some(deleter::<T>),
            data,
        )
    }

    /// Calls the slot directly, invoking the assigned handler (if any).
    #[inline(always)]
    pub unsafe fn slot(
        &self,
        arg0: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_slot_(
            self as *const crate::SlotOfQObjectQUrl as *mut crate::SlotOfQObjectQUrl,
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg0)
                .as_raw_ptr() as *mut ::qt_core::QObject,
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(arg1).as_raw_ptr(),
        )
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_tr(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_trUtf8(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::qt_core::AsReceiver for crate::SlotOfStatus {
    type Arguments = (crate::q_qml_component::Status,);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"1slot_(QQmlComponent::Status)\0"),
            )
        }
    }
}

/// Binds a Qt signal with arguments `crate::q_qml_component::Status` to a Rust closure.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```QQmlComponent::Status```</span>).
///
/// Create an object using `new()` and bind your closure using `set()`. The closure will be called with the signal's arguments when the slot is invoked. Use `connect()` method of a `qt_core::Signal` object to connect the signal to this slot. The closure will be executed each time the slot is invoked until source signals are disconnected or the slot object is destroyed.
///
/// The slot object takes ownership of the passed closure. If `set()` is called again, previously set closure is dropped. Make sure that the slot object does not outlive objects referenced by the closure.
///
/// If `set()` was not called, slot invocation has no effect.
#[repr(C)]
pub struct SlotOfStatus {
    _unused: u8,
}
impl SlotOfStatus {
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_metaObject(
                self as *const crate::SlotOfStatus,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new<T: FnMut(crate::q_qml_component::Status) + 'static>(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        callback: T,
    ) -> ::qt_core::QBox<crate::SlotOfStatus> {
        let ffi_result = {
            extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
                unsafe {
                    let _ = Box::from_raw(data as *mut T);
                }
            }
            extern "C" fn ffi_callback<T: FnMut(crate::q_qml_component::Status) + 'static>(
                data: *mut ::std::ffi::c_void,
                arg0: crate::q_qml_component::Status,
            ) {
                unsafe { (*(data as *mut T))(arg0) }
            }
            let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status(::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent).as_raw_ptr() as *mut ::qt_core::QObject, Some(ffi_callback::<T>), Some(deleter::<T>), data)
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_qt_metacall(
            self as *const crate::SlotOfStatus as *mut crate::SlotOfStatus,
            arg1,
            arg2,
            arg3,
        )
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_qt_metacast(
            self as *const crate::SlotOfStatus as *mut crate::SlotOfStatus,
            arg1,
        )
    }

    /// Assigns `callback` as the signal handler.
    ///
    /// `func` will be called each time a connected signal is emitted. Any previously assigned function will be deregistered. Passing `None` will deregister the handler without setting a new one.
    #[inline(always)]
    pub unsafe fn set<T: FnMut(crate::q_qml_component::Status) + 'static>(&self, callback: T) {
        extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
            unsafe {
                let _ = Box::from_raw(data as *mut T);
            }
        }
        extern "C" fn ffi_callback<T: FnMut(crate::q_qml_component::Status) + 'static>(
            data: *mut ::std::ffi::c_void,
            arg0: crate::q_qml_component::Status,
        ) {
            unsafe { (*(data as *mut T))(arg0) }
        }
        let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_set(
            self as *const crate::SlotOfStatus as *mut crate::SlotOfStatus,
            Some(ffi_callback::<T>),
            Some(deleter::<T>),
            data,
        )
    }

    /// Calls the slot directly, invoking the assigned handler (if any).
    #[inline(always)]
    pub unsafe fn slot(&self, arg0: crate::q_qml_component::Status) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_slot_(
            self as *const crate::SlotOfStatus as *mut crate::SlotOfStatus,
            arg0,
        )
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_tr(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_trUtf8(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::qt_core::AsReceiver for crate::SlotOfQListOfQQmlError {
    type Arguments = (*const crate::QListOfQQmlError,);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"1slot_(QList< QQmlError > const &)\0",
                ),
            )
        }
    }
}

/// Binds a Qt signal with arguments `*const crate::QListOfQQmlError` to a Rust closure.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```const QList<QQmlError>&```</span>).
///
/// Create an object using `new()` and bind your closure using `set()`. The closure will be called with the signal's arguments when the slot is invoked. Use `connect()` method of a `qt_core::Signal` object to connect the signal to this slot. The closure will be executed each time the slot is invoked until source signals are disconnected or the slot object is destroyed.
///
/// The slot object takes ownership of the passed closure. If `set()` is called again, previously set closure is dropped. Make sure that the slot object does not outlive objects referenced by the closure.
///
/// If `set()` was not called, slot invocation has no effect.
#[repr(C)]
pub struct SlotOfQListOfQQmlError {
    _unused: u8,
}
impl SlotOfQListOfQQmlError {
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_metaObject(self as *const crate::SlotOfQListOfQQmlError)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new<T: FnMut(::cpp_core::Ref<crate::QListOfQQmlError>) + 'static>(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        callback: T,
    ) -> ::qt_core::QBox<crate::SlotOfQListOfQQmlError> {
        let ffi_result = {
            extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
                unsafe {
                    let _ = Box::from_raw(data as *mut T);
                }
            }
            extern "C" fn ffi_callback<
                T: FnMut(::cpp_core::Ref<crate::QListOfQQmlError>) + 'static,
            >(
                data: *mut ::std::ffi::c_void,
                arg0: *const crate::QListOfQQmlError,
            ) {
                unsafe {
                    (*(data as *mut T))(
                        ::cpp_core::Ref::from_raw(arg0 as *mut crate::QListOfQQmlError)
                            .expect("attempted to construct a null Ref"),
                    )
                }
            }
            let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref(::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent).as_raw_ptr() as *mut ::qt_core::QObject, Some(ffi_callback::<T>), Some(deleter::<T>), data)
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_qt_metacall(self as *const crate::SlotOfQListOfQQmlError as *mut crate::SlotOfQListOfQQmlError, arg1, arg2, arg3)
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_qt_metacast(self as *const crate::SlotOfQListOfQQmlError as *mut crate::SlotOfQListOfQQmlError, arg1)
    }

    /// Assigns `callback` as the signal handler.
    ///
    /// `func` will be called each time a connected signal is emitted. Any previously assigned function will be deregistered. Passing `None` will deregister the handler without setting a new one.
    #[inline(always)]
    pub unsafe fn set<T: FnMut(::cpp_core::Ref<crate::QListOfQQmlError>) + 'static>(
        &self,
        callback: T,
    ) {
        extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
            unsafe {
                let _ = Box::from_raw(data as *mut T);
            }
        }
        extern "C" fn ffi_callback<T: FnMut(::cpp_core::Ref<crate::QListOfQQmlError>) + 'static>(
            data: *mut ::std::ffi::c_void,
            arg0: *const crate::QListOfQQmlError,
        ) {
            unsafe {
                (*(data as *mut T))(
                    ::cpp_core::Ref::from_raw(arg0 as *mut crate::QListOfQQmlError)
                        .expect("attempted to construct a null Ref"),
                )
            }
        }
        let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_set(
            self as *const crate::SlotOfQListOfQQmlError as *mut crate::SlotOfQListOfQQmlError,
            Some(ffi_callback::<T>),
            Some(deleter::<T>),
            data,
        )
    }

    /// Calls the slot directly, invoking the assigned handler (if any).
    #[inline(always)]
    pub unsafe fn slot(
        &self,
        arg0: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QListOfQQmlError>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_slot_(
            self as *const crate::SlotOfQListOfQQmlError as *mut crate::SlotOfQListOfQQmlError,
            ::cpp_core::CastInto::<::cpp_core::Ref<crate::QListOfQQmlError>>::cast_into(arg0)
                .as_raw_ptr(),
        )
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_tr(
                s, c, n,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_trUtf8(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::qt_core::AsReceiver for crate::SlotOfQStringQVariant {
    type Arguments = (*const ::qt_core::QString, *const ::qt_core::QVariant);
    fn as_receiver(&self) -> ::qt_core::Receiver<Self::Arguments> {
        unsafe {
            ::qt_core::Receiver::new(
                ::cpp_core::Ref::from_raw(self).expect("attempted to construct a null Ref"),
                ::std::ffi::CStr::from_bytes_with_nul_unchecked(
                    b"1slot_(QString const &,QVariant const &)\0",
                ),
            )
        }
    }
}

/// Binds a Qt signal with arguments `*const ::qt_core::QString,*const ::qt_core::QVariant` to a Rust closure.
///
/// Corresponding C++ argument types: (<span style='color: green;'>```const QString&, const QVariant&```</span>).
///
/// Create an object using `new()` and bind your closure using `set()`. The closure will be called with the signal's arguments when the slot is invoked. Use `connect()` method of a `qt_core::Signal` object to connect the signal to this slot. The closure will be executed each time the slot is invoked until source signals are disconnected or the slot object is destroyed.
///
/// The slot object takes ownership of the passed closure. If `set()` is called again, previously set closure is dropped. Make sure that the slot object does not outlive objects referenced by the closure.
///
/// If `set()` was not called, slot invocation has no effect.
#[repr(C)]
pub struct SlotOfQStringQVariant {
    _unused: u8,
}
impl SlotOfQStringQVariant {
    #[inline(always)]
    pub unsafe fn meta_object(&self) -> ::cpp_core::Ptr<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_metaObject(self as *const crate::SlotOfQStringQVariant)
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
    }

    /// Creates a new object.
    #[inline(always)]
    pub unsafe fn new<
        T: FnMut(::cpp_core::Ref<::qt_core::QString>, ::cpp_core::Ref<::qt_core::QVariant>) + 'static,
    >(
        parent: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
        callback: T,
    ) -> ::qt_core::QBox<crate::SlotOfQStringQVariant> {
        let ffi_result = {
            extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
                unsafe {
                    let _ = Box::from_raw(data as *mut T);
                }
            }
            extern "C" fn ffi_callback<
                T: FnMut(::cpp_core::Ref<::qt_core::QString>, ::cpp_core::Ref<::qt_core::QVariant>)
                    + 'static,
            >(
                data: *mut ::std::ffi::c_void,
                arg0: *const ::qt_core::QString,
                arg1: *const ::qt_core::QVariant,
            ) {
                unsafe {
                    (*(data as *mut T))(
                        ::cpp_core::Ref::from_raw(arg0 as *mut ::qt_core::QString)
                            .expect("attempted to construct a null Ref"),
                        ::cpp_core::Ref::from_raw(arg1 as *mut ::qt_core::QVariant)
                            .expect("attempted to construct a null Ref"),
                    )
                }
            }
            let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref(::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(parent).as_raw_ptr() as *mut ::qt_core::QObject, Some(ffi_callback::<T>), Some(deleter::<T>), data)
        };
        ::qt_core::QBox::from_raw(ffi_result)
    }

    #[inline(always)]
    pub unsafe fn qt_metacall(
        &self,
        arg1: ::qt_core::q_meta_object::Call,
        arg2: ::std::os::raw::c_int,
        arg3: *mut *mut ::std::ffi::c_void,
    ) -> ::std::os::raw::c_int {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_qt_metacall(self as *const crate::SlotOfQStringQVariant as *mut crate::SlotOfQStringQVariant, arg1, arg2, arg3)
    }

    #[inline(always)]
    pub unsafe fn qt_metacast(
        &self,
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::ffi::c_void {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_qt_metacast(self as *const crate::SlotOfQStringQVariant as *mut crate::SlotOfQStringQVariant, arg1)
    }

    /// Assigns `callback` as the signal handler.
    ///
    /// `func` will be called each time a connected signal is emitted. Any previously assigned function will be deregistered. Passing `None` will deregister the handler without setting a new one.
    #[inline(always)]
    pub unsafe fn set<
        T: FnMut(::cpp_core::Ref<::qt_core::QString>, ::cpp_core::Ref<::qt_core::QVariant>) + 'static,
    >(
        &self,
        callback: T,
    ) {
        extern "C" fn deleter<T>(data: *mut ::std::ffi::c_void) {
            unsafe {
                let _ = Box::from_raw(data as *mut T);
            }
        }
        extern "C" fn ffi_callback<
            T: FnMut(::cpp_core::Ref<::qt_core::QString>, ::cpp_core::Ref<::qt_core::QVariant>)
                + 'static,
        >(
            data: *mut ::std::ffi::c_void,
            arg0: *const ::qt_core::QString,
            arg1: *const ::qt_core::QVariant,
        ) {
            unsafe {
                (*(data as *mut T))(
                    ::cpp_core::Ref::from_raw(arg0 as *mut ::qt_core::QString)
                        .expect("attempted to construct a null Ref"),
                    ::cpp_core::Ref::from_raw(arg1 as *mut ::qt_core::QVariant)
                        .expect("attempted to construct a null Ref"),
                )
            }
        }
        let data = Box::into_raw(Box::new(callback)) as *mut ::std::ffi::c_void;
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_set(self as *const crate::SlotOfQStringQVariant as *mut crate::SlotOfQStringQVariant, Some(ffi_callback::<T>), Some(deleter::<T>), data)
    }

    /// Calls the slot directly, invoking the assigned handler (if any).
    #[inline(always)]
    pub unsafe fn slot(
        &self,
        arg0: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
        arg1: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
    ) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_slot_(self as *const crate::SlotOfQStringQVariant as *mut crate::SlotOfQStringQVariant, ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(arg0).as_raw_ptr(), ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(arg1).as_raw_ptr())
    }

    #[inline(always)]
    pub unsafe fn static_meta_object() -> ::cpp_core::Ref<::qt_core::QMetaObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_staticMetaObject()
        };
        ::cpp_core::Ref::from_raw(ffi_result as *mut ::qt_core::QMetaObject)
            .expect("attempted to construct a null Ref")
    }

    #[inline(always)]
    pub unsafe fn tr(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_tr(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }

    #[inline(always)]
    pub unsafe fn tr_utf8(
        s: *const ::std::os::raw::c_char,
        c: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> ::cpp_core::CppBox<::qt_core::QString> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_trUtf8(s, c, n)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::CppDeletable for crate::QJSValue {
    /// <p>Destroys this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QJSValue::~QJSValue()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalue.html#dtor.QJSValue">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys this <a href="http://doc.qt.io/qt-5/qjsvalue.html">QJSValue</a>.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QJSValue_dQJSValue(
            self as *const crate::QJSValue as *mut crate::QJSValue,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QJSEngine {
    /// <p>Destroys this <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QJSEngine::~QJSEngine()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsengine.html#dtor.QJSEngine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys this <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a>.</p>
    /// <p>Garbage is not collected from the persistent JS heap during <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> destruction. If you need all memory freed, call <a href="http://doc.qt.io/qt-5/qjsengine.html#collectGarbage">collectGarbage</a> manually right before destroying the <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a>.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QJSEngine_dQJSEngine(
            self as *const crate::QJSEngine as *mut crate::QJSEngine,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QJSValueIterator {
    /// <p>Destroys the iterator.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QJSValueIterator::~QJSValueIterator()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qjsvalueiterator.html#dtor.QJSValueIterator">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the iterator.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QJSValueIterator_dQJSValueIterator(
            self as *const crate::QJSValueIterator as *mut crate::QJSValueIterator,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlParserStatus {
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlParserStatus::~QQmlParserStatus()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlParserStatus_dQQmlParserStatus(
            self as *const crate::QQmlParserStatus as *mut crate::QQmlParserStatus,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlPropertyValueSource {
    /// <p>Destroys the value source.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlPropertyValueSource::~QQmlPropertyValueSource()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertyvaluesource.html#dtor.QQmlPropertyValueSource">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the value source.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyValueSource_dQQmlPropertyValueSource(
            self as *const crate::QQmlPropertyValueSource as *mut crate::QQmlPropertyValueSource,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlListReference {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlListReference::~QQmlListReference()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlListReference_dQQmlListReference(
            self as *const crate::QQmlListReference as *mut crate::QQmlListReference,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlAbstractUrlInterceptor {
    /// <p>Destructor for <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlAbstractUrlInterceptor::~QQmlAbstractUrlInterceptor()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html#dtor.QQmlAbstractUrlInterceptor">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destructor for <a href="http://doc.qt.io/qt-5/qqmlabstracturlinterceptor.html">QQmlAbstractUrlInterceptor</a>.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlAbstractUrlInterceptor_dQQmlAbstractUrlInterceptor(
            self as *const crate::QQmlAbstractUrlInterceptor
                as *mut crate::QQmlAbstractUrlInterceptor,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlError {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlError::~QQmlError()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlError_dQQmlError(
            self as *const crate::QQmlError as *mut crate::QQmlError,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlImageProviderBase {
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlImageProviderBase::~QQmlImageProviderBase()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlImageProviderBase_dQQmlImageProviderBase(
            self as *const crate::QQmlImageProviderBase as *mut crate::QQmlImageProviderBase,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlEngine {
    /// <p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlEngine::~QQmlEngine()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlengine.html#dtor.QQmlEngine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a>.</p>
    /// <p>Any <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>'s created on this engine will be invalidated, but not destroyed (unless they are parented to the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> object).</p>
    /// <p>See <a href="http://doc.qt.io/qt-5/qjsengine.html">QJSEngine</a> docs for details on cleaning up the JS engine.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlEngine_dQQmlEngine(
            self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlApplicationEngine {
    /// <p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and all QML objects it loaded.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlApplicationEngine::~QQmlApplicationEngine()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html#dtor.QQmlApplicationEngine">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlapplicationengine.html">QQmlApplicationEngine</a> and all QML objects it loaded.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlApplicationEngine_dQQmlApplicationEngine(
            self as *const crate::QQmlApplicationEngine as *mut crate::QQmlApplicationEngine,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlComponent {
    /// <p>Destruct the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlComponent::~QQmlComponent()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcomponent.html#dtor.QQmlComponent">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destruct the <a href="http://doc.qt.io/qt-5/qqmlcomponent.html">QQmlComponent</a>.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlComponent_dQQmlComponent(
            self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlContext {
    /// <p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlContext::~QQmlContext()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlcontext.html#dtor.QQmlContext">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a>.</p>
    /// <p>Any expressions, or sub-contexts dependent on this context will be invalidated, but not destroyed (unless they are parented to the <a href="http://doc.qt.io/qt-5/qqmlcontext.html">QQmlContext</a> object).</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlContext_dQQmlContext(
            self as *const crate::QQmlContext as *mut crate::QQmlContext,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlScriptString {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlScriptString::~QQmlScriptString()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_dQQmlScriptString(
            self as *const crate::QQmlScriptString as *mut crate::QQmlScriptString,
        )
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::QQmlScriptString>> for crate::QQmlScriptString {
    /// <p>Returns <code>true</code> if this and the <i>other</i> <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> objects are equal.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlScriptString::operator==(const QQmlScriptString& arg1) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#operator-eq-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if this and the <i>other</i> <a href="http://doc.qt.io/qt-5/qqmlscriptstring.html">QQmlScriptString</a> objects are equal.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlscriptstring.html#operator-not-eq">operator!=</a>().</p></div>
    #[inline(always)]
    fn eq(&self, arg1: &::cpp_core::Ref<crate::QQmlScriptString>) -> bool {
        unsafe {
            crate::__ffi::ctr_qt_qml_ffi_QQmlScriptString_operator__(
                self as *const crate::QQmlScriptString,
                arg1.as_raw_ptr(),
            )
        }
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlExpression {
    /// <p>Destroy the <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> instance.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlExpression::~QQmlExpression()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlexpression.html#dtor.QQmlExpression">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroy the <a href="http://doc.qt.io/qt-5/qqmlexpression.html">QQmlExpression</a> instance.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExpression_dQQmlExpression(
            self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlTypesExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlTypesExtensionInterface::~QQmlTypesExtensionInterface()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlTypesExtensionInterface_dQQmlTypesExtensionInterface(
            self as *const crate::QQmlTypesExtensionInterface
                as *mut crate::QQmlTypesExtensionInterface,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlExtensionInterface::~QQmlExtensionInterface()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionInterface_dQQmlExtensionInterface(
            self as *const crate::QQmlExtensionInterface as *mut crate::QQmlExtensionInterface,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlExtensionPlugin {
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlExtensionPlugin::~QQmlExtensionPlugin()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlExtensionPlugin_dQQmlExtensionPlugin(
            self as *const crate::QQmlExtensionPlugin as *mut crate::QQmlExtensionPlugin,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlFile {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlFile::~QQmlFile()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_dQQmlFile(
            self as *const crate::QQmlFile as *mut crate::QQmlFile,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::QQmlFile {
    /// Calls C++ function: <span style='color: green;'>```qint64 QQmlFile::size() const```</span>.
    #[inline(always)]
    unsafe fn size(&self) -> usize {
        let ffi_result =
            { crate::__ffi::ctr_qt_qml_ffi_QQmlFile_size(self as *const crate::QQmlFile) };
        ffi_result as usize
    }
}

impl ::cpp_core::vector_ops::Data for crate::QQmlFile {
    type Output = *const ::std::os::raw::c_char;
    /// Calls C++ function: <span style='color: green;'>```const char* QQmlFile::data() const```</span>.
    #[inline(always)]
    unsafe fn data(&self) -> *const ::std::os::raw::c_char {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFile_data(self as *const crate::QQmlFile)
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlFileSelector {
    /// <p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> object.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlFileSelector::~QQmlFileSelector()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlfileselector.html#dtor.QQmlFileSelector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the <a href="http://doc.qt.io/qt-5/qqmlfileselector.html">QQmlFileSelector</a> object.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlFileSelector_dQQmlFileSelector(
            self as *const crate::QQmlFileSelector as *mut crate::QQmlFileSelector,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlIncubator {
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlIncubator::~QQmlIncubator()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubator_dQQmlIncubator(
            self as *const crate::QQmlIncubator as *mut crate::QQmlIncubator,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlIncubationController {
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlIncubationController::~QQmlIncubationController()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlIncubationController_dQQmlIncubationController(
            self as *const crate::QQmlIncubationController as *mut crate::QQmlIncubationController,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlInfo {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlInfo::~QQmlInfo()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_dQQmlInfo(
            self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
        )
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<::qt_core::QChar>> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(QChar t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<::qt_core::QChar>) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<bool> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(bool t)```</span>.
    #[inline(always)]
    fn shl(self, t: bool) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__1(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t,
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::std::os::raw::c_char> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(char t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::std::os::raw::c_char) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__2(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t,
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<i64> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(qint64 t)```</span>.
    #[inline(always)]
    fn shl(self, t: i64) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__9(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t,
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::std::os::raw::c_float> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(float t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::std::os::raw::c_float) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__11(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t,
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<*const ::std::os::raw::c_char> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(const char* t)```</span>.
    #[inline(always)]
    fn shl(self, t: *const ::std::os::raw::c_char) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__13(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t,
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<::qt_core::QString>> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(const QString& t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<::qt_core::QString>) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__14(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<::qt_core::QStringRef>> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(const QStringRef& t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<::qt_core::QStringRef>) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__15(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<::qt_core::QLatin1String>> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(const QLatin1String& t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<::qt_core::QLatin1String>) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__16(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<::qt_core::QByteArray>> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(const QByteArray& t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<::qt_core::QByteArray>) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__17(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<*const ::std::ffi::c_void> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(const void* t)```</span>.
    #[inline(always)]
    fn shl(self, t: *const ::std::ffi::c_void) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__18(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t,
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<::qt_core::QTextStreamManipulator>> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(QTextStreamManipulator m)```</span>.
    #[inline(always)]
    fn shl(
        self,
        m: ::cpp_core::Ref<::qt_core::QTextStreamManipulator>,
    ) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__20(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    m.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<::qt_core::QUrl>> for &crate::QQmlInfo {
    type Output = ::cpp_core::Ref<crate::QQmlInfo>;
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo& QQmlInfo::operator<<(const QUrl& t)```</span>.
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<::qt_core::QUrl>) -> ::cpp_core::Ref<crate::QQmlInfo> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QQmlInfo_operator__21(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlNetworkAccessManagerFactory {
    /// <p>Destroys the factory. The default implementation does nothing.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlNetworkAccessManagerFactory::~QQmlNetworkAccessManagerFactory()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlnetworkaccessmanagerfactory.html#dtor.QQmlNetworkAccessManagerFactory">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the factory. The default implementation does nothing.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlNetworkAccessManagerFactory_dQQmlNetworkAccessManagerFactory(self as *const crate::QQmlNetworkAccessManagerFactory as *mut crate::QQmlNetworkAccessManagerFactory)
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlProperty {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlProperty::~QQmlProperty()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_dQQmlProperty(
            self as *const crate::QQmlProperty as *mut crate::QQmlProperty,
        )
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::QQmlProperty>> for crate::QQmlProperty {
    /// <p>Returns true if <i>other</i> and this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> represent the same property.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool QQmlProperty::operator==(const QQmlProperty& arg1) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlproperty.html#operator-eq-eq">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns true if <i>other</i> and this <a href="http://doc.qt.io/qt-5/qqmlproperty.html">QQmlProperty</a> represent the same property.</p></div>
    #[inline(always)]
    fn eq(&self, arg1: &::cpp_core::Ref<crate::QQmlProperty>) -> bool {
        unsafe {
            crate::__ffi::ctr_qt_qml_ffi_QQmlProperty_operator__(
                self as *const crate::QQmlProperty,
                arg1.as_raw_ptr(),
            )
        }
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlPropertyMap {
    /// <p>Destroys the bindable map.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```virtual [destructor] void QQmlPropertyMap::~QQmlPropertyMap()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#dtor.QQmlPropertyMap">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the bindable map.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_dQQmlPropertyMap(
            self as *const crate::QQmlPropertyMap as *mut crate::QQmlPropertyMap,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::QQmlPropertyMap {
    /// <p>Returns the number of keys in the map.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QQmlPropertyMap::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of keys in the map.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qqmlpropertymap.html#count">count</a>().</p></div>
    #[inline(always)]
    unsafe fn size(&self) -> usize {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QQmlPropertyMap_size(self as *const crate::QQmlPropertyMap)
        };
        ffi_result as usize
    }
}

impl ::cpp_core::CppDeletable for crate::QQmlDebuggingEnabler {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QQmlDebuggingEnabler::~QQmlDebuggingEnabler()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QQmlDebuggingEnabler_dQQmlDebuggingEnabler(
            self as *const crate::QQmlDebuggingEnabler as *mut crate::QQmlDebuggingEnabler,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QListOfQJSValue {
    /// <p>Destroys the list. References to the values in the list and all iterators of this list become invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QJSValue>::~QList()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#dtor.QList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the list. References to the values in the list and all iterators of this list become invalid.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_dQList(
            self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::QListOfQQmlError {
    /// <p>Destroys the list. References to the values in the list and all iterators of this list become invalid.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QList<QQmlError>::~QList()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#dtor.QList">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the list. References to the values in the list and all iterators of this list become invalid.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_dQList(
            self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
        )
    }
}

impl ::cpp_core::vector_ops::Size for crate::QListOfQJSValue {
    /// <p>Returns the number of items in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QJSValue>::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p></div>
    #[inline(always)]
    unsafe fn size(&self) -> usize {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_size(self as *const crate::QListOfQJSValue)
        };
        ffi_result as usize
    }
}

impl ::cpp_core::vector_ops::Size for crate::QListOfQQmlError {
    /// <p>Returns the number of items in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QList<QQmlError>::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#count-1">count</a>().</p></div>
    #[inline(always)]
    unsafe fn size(&self) -> usize {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_size(
                self as *const crate::QListOfQQmlError,
            )
        };
        ffi_result as usize
    }
}

impl ::cpp_core::ops::BeginMut for crate::QListOfQJSValue {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator>;
    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::begin()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    unsafe fn begin_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_begin(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::ops::BeginMut for crate::QListOfQQmlError {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator>;
    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::begin()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the first item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#constBegin">constBegin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#end">end</a>().</p></div>
    #[inline(always)]
    unsafe fn begin_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_begin(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::ops::Begin for crate::QListOfQJSValue {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator>;
    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::begin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    unsafe fn begin(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_begin1(
                self as *const crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::ops::Begin for crate::QListOfQQmlError {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator>;
    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::begin() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#begin-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    unsafe fn begin(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_begin1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::ops::EndMut for crate::QListOfQJSValue {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator>;
    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::iterator QList<QJSValue>::end()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">constEnd</a>().</p></div>
    #[inline(always)]
    unsafe fn end_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_end(
                self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::ops::EndMut for crate::QListOfQQmlError {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator>;
    /// <p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::iterator QList<QQmlError>::end()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns an <a href="http://doc.qt.io/qt-5/containers.html#stl-style-iterators">STL-style iterator</a> pointing to the imaginary item after the last item in the list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#begin">begin</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#constEnd">constEnd</a>().</p></div>
    #[inline(always)]
    unsafe fn end_mut(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::Iterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_end(
                self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::ops::End for crate::QListOfQJSValue {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator>;
    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>::const_iterator QList<QJSValue>::end() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    unsafe fn end(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_j_s_value::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_end1(self as *const crate::QListOfQJSValue)
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::cpp_core::ops::End for crate::QListOfQQmlError {
    type Output = ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator>;
    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>::const_iterator QList<QQmlError>::end() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#end-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    unsafe fn end(&self) -> ::cpp_core::CppBox<crate::q_list_of_q_qml_error::ConstIterator> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_end1(
                self as *const crate::QListOfQQmlError,
            )
        };
        ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
    }
}

impl ::std::ops::Add<::cpp_core::Ref<crate::QListOfQJSValue>> for &crate::QListOfQJSValue {
    type Output = ::cpp_core::CppBox<crate::QListOfQJSValue>;
    /// <p>Returns a list that contains all the items in this list followed by all the items in the <i>other</i> list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue> QList<QJSValue>::operator+(const QList<QJSValue>& l) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a list that contains all the items in this list followed by all the items in the <i>other</i> list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">operator+=</a>().</p></div>
    #[inline(always)]
    fn add(
        self,
        l: ::cpp_core::Ref<crate::QListOfQJSValue>,
    ) -> ::cpp_core::CppBox<crate::QListOfQJSValue> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator_2(
                    self as *const crate::QListOfQJSValue,
                    l.as_raw_ptr(),
                )
            }
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Add<::cpp_core::Ref<crate::QListOfQQmlError>> for &crate::QListOfQQmlError {
    type Output = ::cpp_core::CppBox<crate::QListOfQQmlError>;
    /// <p>Returns a list that contains all the items in this list followed by all the items in the <i>other</i> list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError> QList<QQmlError>::operator+(const QList<QQmlError>& l) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a list that contains all the items in this list followed by all the items in the <i>other</i> list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">operator+=</a>().</p></div>
    #[inline(always)]
    fn add(
        self,
        l: ::cpp_core::Ref<crate::QListOfQQmlError>,
    ) -> ::cpp_core::CppBox<crate::QListOfQQmlError> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator_2(
                    self as *const crate::QListOfQQmlError,
                    l.as_raw_ptr(),
                )
            }
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<crate::QJSValue>> for &crate::QListOfQJSValue {
    type Output = ::cpp_core::Ref<crate::QListOfQJSValue>;
    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>& QList<QJSValue>::operator<<(const QJSValue& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends <i>value</i> to the list.</p></div>
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<crate::QJSValue>) -> ::cpp_core::Ref<crate::QListOfQJSValue> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator__6(
                    self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<crate::QQmlError>> for &crate::QListOfQQmlError {
    type Output = ::cpp_core::Ref<crate::QListOfQQmlError>;
    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>& QList<QQmlError>::operator<<(const QQmlError& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p>
    /// <p>Appends <i>value</i> to the list.</p></div>
    #[inline(always)]
    fn shl(self, t: ::cpp_core::Ref<crate::QQmlError>) -> ::cpp_core::Ref<crate::QListOfQQmlError> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator__6(
                    self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<crate::QListOfQJSValue>> for &crate::QListOfQJSValue {
    type Output = ::cpp_core::Ref<crate::QListOfQJSValue>;
    /// <p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QJSValue>& QList<QJSValue>::operator<<(const QList<QJSValue>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">operator+=</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>().</p></div>
    #[inline(always)]
    fn shl(
        self,
        l: ::cpp_core::Ref<crate::QListOfQJSValue>,
    ) -> ::cpp_core::Ref<crate::QListOfQJSValue> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QJSValue_operator__7(
                    self as *const crate::QListOfQJSValue as *mut crate::QListOfQJSValue,
                    l.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::std::ops::Shl<::cpp_core::Ref<crate::QListOfQQmlError>> for &crate::QListOfQQmlError {
    type Output = ::cpp_core::Ref<crate::QListOfQQmlError>;
    /// <p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QList<QQmlError>& QList<QQmlError>::operator<<(const QList<QQmlError>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qlist.html#operator-lt-lt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends the items of the <i>other</i> list to this list and returns a reference to this list.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qlist.html#operator-2b-eq">operator+=</a>() and <a href="http://doc.qt.io/qt-5/qlist.html#append">append</a>().</p></div>
    #[inline(always)]
    fn shl(
        self,
        l: ::cpp_core::Ref<crate::QListOfQQmlError>,
    ) -> ::cpp_core::Ref<crate::QListOfQQmlError> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QList_QQmlError_operator__7(
                    self as *const crate::QListOfQQmlError as *mut crate::QListOfQQmlError,
                    l.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
impl ::cpp_core::CppDeletable for crate::QVectorOfPropertyPair {
    /// <p>Destroys the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QVector<QQmlContext::PropertyPair>::~QVector()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#dtor.QVector">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Destroys the vector.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_dQVector(
            self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
        )
    }
}

#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
impl ::cpp_core::vector_ops::Size for crate::QVectorOfPropertyPair {
    /// <p>Returns the number of items in the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```int QVector<QQmlContext::PropertyPair>::size() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#size">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the number of items in the vector.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#isEmpty">isEmpty</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#resize">resize</a>().</p></div>
    #[inline(always)]
    unsafe fn size(&self) -> usize {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_size(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ffi_result as usize
    }
}

#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
impl ::cpp_core::vector_ops::DataMut for crate::QVectorOfPropertyPair {
    type Output = ::cpp_core::Ptr<crate::q_qml_context::PropertyPair>;
    /// <p>Returns a pointer to the data stored in the vector. The pointer can be used to access and modify the items in the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QQmlContext::PropertyPair* QVector<QQmlContext::PropertyPair>::data()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#data">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a pointer to the data stored in the vector. The pointer can be used to access and modify the items in the vector.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    ///   <span class="type"><a href="http://doc.qt.io/qt-5/qvector.html#QVector">QVector</a></span><span class="operator">&lt;</span><span class="type">int</span><span class="operator">&gt;</span> vector(<span class="number">10</span>);
    ///   <span class="type">int</span> <span class="operator">*</span>data <span class="operator">=</span> vector<span class="operator">.</span>data();
    ///   <span class="keyword">for</span> (<span class="type">int</span> i <span class="operator">=</span> <span class="number">0</span>; i <span class="operator">&lt;</span> <span class="number">10</span>; <span class="operator">+</span><span class="operator">+</span>i)
    /// &#32;     data<span class="operator">[</span>i<span class="operator">]</span> <span class="operator">=</span> <span class="number">2</span> <span class="operator">*</span> i;
    ///
    /// </pre>
    /// <p>The pointer remains valid as long as the vector isn't reallocated.</p>
    /// <p>This function is mostly useful to pass a vector to a function that accepts a plain C++ array.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#constData">constData</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-5b-5d">operator[]</a>().</p></div>
    #[inline(always)]
    unsafe fn data_mut(&self) -> ::cpp_core::Ptr<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_data(
                self as *const crate::QVectorOfPropertyPair as *mut crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
impl ::cpp_core::vector_ops::Data for crate::QVectorOfPropertyPair {
    type Output = ::cpp_core::Ptr<crate::q_qml_context::PropertyPair>;
    /// <p>This is an overloaded function.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```const QQmlContext::PropertyPair* QVector<QQmlContext::PropertyPair>::data() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#data-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This is an overloaded function.</p></div>
    #[inline(always)]
    unsafe fn data(&self) -> ::cpp_core::Ptr<crate::q_qml_context::PropertyPair> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_data1(
                self as *const crate::QVectorOfPropertyPair,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result as *mut crate::q_qml_context::PropertyPair)
    }
}

#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
impl ::std::ops::Add<::cpp_core::Ref<crate::QVectorOfPropertyPair>>
    for &crate::QVectorOfPropertyPair
{
    type Output = ::cpp_core::CppBox<crate::QVectorOfPropertyPair>;
    /// <p>Returns a vector that contains all the items in this vector followed by all the items in the <i>other</i> vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair> QVector<QQmlContext::PropertyPair>::operator+(const QVector<QQmlContext::PropertyPair>& l) const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-2b">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns a vector that contains all the items in this vector followed by all the items in the <i>other</i> vector.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#operator-2b-eq">operator+=</a>().</p></div>
    #[inline(always)]
    fn add(
        self,
        l: ::cpp_core::Ref<crate::QVectorOfPropertyPair>,
    ) -> ::cpp_core::CppBox<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator_2(
                    self as *const crate::QVectorOfPropertyPair,
                    l.as_raw_ptr(),
                )
            }
        };
        unsafe {
            ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
        }
    }
}

#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
impl ::std::ops::Shl<::cpp_core::Ref<crate::q_qml_context::PropertyPair>>
    for &crate::QVectorOfPropertyPair
{
    type Output = ::cpp_core::Ref<crate::QVectorOfPropertyPair>;
    /// <p>Appends <i>value</i> to the vector and returns a reference to this vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>& QVector<QQmlContext::PropertyPair>::operator<<(const QQmlContext::PropertyPair& t)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-lt-lt">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends <i>value</i> to the vector and returns a reference to this vector.</p>
    /// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qvector.html#append">append</a>() and <a href="http://doc.qt.io/qt-5/qvector.html#operator-2b-eq">operator+=</a>().</p></div>
    #[inline(always)]
    fn shl(
        self,
        t: ::cpp_core::Ref<crate::q_qml_context::PropertyPair>,
    ) -> ::cpp_core::Ref<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator__6(
                    self as *const crate::QVectorOfPropertyPair
                        as *mut crate::QVectorOfPropertyPair,
                    t.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.11.3",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
impl ::std::ops::Shl<::cpp_core::Ref<crate::QVectorOfPropertyPair>>
    for &crate::QVectorOfPropertyPair
{
    type Output = ::cpp_core::Ref<crate::QVectorOfPropertyPair>;
    /// <p>Appends <i>other</i> to the vector and returns a reference to the vector.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QVector<QQmlContext::PropertyPair>& QVector<QQmlContext::PropertyPair>::operator<<(const QVector<QQmlContext::PropertyPair>& l)```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qvector.html#operator-lt-lt-1">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Appends <i>other</i> to the vector and returns a reference to the vector.</p></div>
    #[inline(always)]
    fn shl(
        self,
        l: ::cpp_core::Ref<crate::QVectorOfPropertyPair>,
    ) -> ::cpp_core::Ref<crate::QVectorOfPropertyPair> {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_QVector_QQmlContext_PropertyPair_operator__7(
                    self as *const crate::QVectorOfPropertyPair
                        as *mut crate::QVectorOfPropertyPair,
                    l.as_raw_ptr(),
                )
            }
        };
        unsafe { ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref") }
    }
}

impl ::cpp_core::StaticDowncast<crate::QJSEngine> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QJSEngine* static_cast<QJSEngine*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QJSEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QJSEngine_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QJSEngine {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QJSEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QJSEngine>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr(
                ptr.as_raw_ptr() as *mut crate::QJSEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QJSEngine {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QJSEngine* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr(
                    self as *const crate::QJSEngine as *mut crate::QJSEngine,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QJSEngine> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QJSEngine* dynamic_cast<QJSEngine*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QJSEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QJSEngine_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlEngine> for crate::QJSEngine {
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* static_cast<QQmlEngine*>(QJSEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::QJSEngine>,
    ) -> ::cpp_core::Ptr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlEngine_ptr(
                ptr.as_raw_ptr() as *mut crate::QJSEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::QJSEngine> for crate::QQmlEngine {
    /// Calls C++ function: <span style='color: green;'>```QJSEngine* static_cast<QJSEngine*>(QQmlEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlEngine>,
    ) -> ::cpp_core::Ptr<crate::QJSEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QJSEngine_ptr1(
                ptr.as_raw_ptr() as *mut crate::QQmlEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlEngine {
    type Target = crate::QJSEngine;
    /// Calls C++ function: <span style='color: green;'>```QJSEngine* static_cast<QJSEngine*>(QQmlEngine* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &crate::QJSEngine {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QJSEngine_ptr1(
                    self as *const crate::QQmlEngine as *mut crate::QQmlEngine,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlEngine> for crate::QJSEngine {
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* dynamic_cast<QQmlEngine*>(QJSEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<crate::QJSEngine>,
    ) -> ::cpp_core::Ptr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlEngine_ptr(
                ptr.as_raw_ptr() as *mut crate::QJSEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlEngine> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* static_cast<QQmlEngine*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlEngine_ptr1(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlEngine {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlEngine>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr1(
                ptr.as_raw_ptr() as *mut crate::QQmlEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlEngine> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* dynamic_cast<QQmlEngine*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlEngine_ptr1(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlApplicationEngine> for crate::QQmlEngine {
    /// Calls C++ function: <span style='color: green;'>```QQmlApplicationEngine* static_cast<QQmlApplicationEngine*>(QQmlEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::QQmlEngine>,
    ) -> ::cpp_core::Ptr<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlApplicationEngine_ptr(
                ptr.as_raw_ptr() as *mut crate::QQmlEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::QQmlEngine> for crate::QQmlApplicationEngine {
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* static_cast<QQmlEngine*>(QQmlApplicationEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlApplicationEngine>,
    ) -> ::cpp_core::Ptr<crate::QQmlEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlEngine_ptr2(
                ptr.as_raw_ptr() as *mut crate::QQmlApplicationEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlApplicationEngine {
    type Target = crate::QQmlEngine;
    /// Calls C++ function: <span style='color: green;'>```QQmlEngine* static_cast<QQmlEngine*>(QQmlApplicationEngine* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &crate::QQmlEngine {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlEngine_ptr2(
                    self as *const crate::QQmlApplicationEngine
                        as *mut crate::QQmlApplicationEngine,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlApplicationEngine> for crate::QQmlEngine {
    /// Calls C++ function: <span style='color: green;'>```QQmlApplicationEngine* dynamic_cast<QQmlApplicationEngine*>(QQmlEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<crate::QQmlEngine>,
    ) -> ::cpp_core::Ptr<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlApplicationEngine_ptr(
                ptr.as_raw_ptr() as *mut crate::QQmlEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlApplicationEngine> for crate::QJSEngine {
    /// Calls C++ function: <span style='color: green;'>```QQmlApplicationEngine* static_cast<QQmlApplicationEngine*>(QJSEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::QJSEngine>,
    ) -> ::cpp_core::Ptr<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlApplicationEngine_ptr1(
                ptr.as_raw_ptr() as *mut crate::QJSEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::QJSEngine> for crate::QQmlApplicationEngine {
    /// Calls C++ function: <span style='color: green;'>```QJSEngine* static_cast<QJSEngine*>(QQmlApplicationEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlApplicationEngine>,
    ) -> ::cpp_core::Ptr<crate::QJSEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QJSEngine_ptr2(
                ptr.as_raw_ptr() as *mut crate::QQmlApplicationEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlApplicationEngine> for crate::QJSEngine {
    /// Calls C++ function: <span style='color: green;'>```QQmlApplicationEngine* dynamic_cast<QQmlApplicationEngine*>(QJSEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<crate::QJSEngine>,
    ) -> ::cpp_core::Ptr<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlApplicationEngine_ptr1(
                ptr.as_raw_ptr() as *mut crate::QJSEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlApplicationEngine> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlApplicationEngine* static_cast<QQmlApplicationEngine*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlApplicationEngine_ptr2(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlApplicationEngine {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlApplicationEngine* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlApplicationEngine>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr2(
                ptr.as_raw_ptr() as *mut crate::QQmlApplicationEngine
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlApplicationEngine> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlApplicationEngine* dynamic_cast<QQmlApplicationEngine*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlApplicationEngine> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlApplicationEngine_ptr2(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlComponent> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlComponent* static_cast<QQmlComponent*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlComponent_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlComponent {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlComponent* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlComponent>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr3(
                ptr.as_raw_ptr() as *mut crate::QQmlComponent
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlComponent {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlComponent* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr3(
                    self as *const crate::QQmlComponent as *mut crate::QQmlComponent,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlComponent> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlComponent* dynamic_cast<QQmlComponent*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlComponent> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlComponent_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlContext> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlContext* static_cast<QQmlContext*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlContext_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlContext {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlContext* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlContext>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr4(
                ptr.as_raw_ptr() as *mut crate::QQmlContext
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlContext {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlContext* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr4(
                    self as *const crate::QQmlContext as *mut crate::QQmlContext,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlContext> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlContext* dynamic_cast<QQmlContext*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlContext> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlContext_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlExpression> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlExpression* static_cast<QQmlExpression*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlExpression_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlExpression {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlExpression* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlExpression>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr5(
                ptr.as_raw_ptr() as *mut crate::QQmlExpression
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlExpression {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlExpression* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr5(
                    self as *const crate::QQmlExpression as *mut crate::QQmlExpression,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlExpression> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlExpression* dynamic_cast<QQmlExpression*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlExpression> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlExpression_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlExtensionInterface>
    for crate::QQmlTypesExtensionInterface
{
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionInterface* static_cast<QQmlExtensionInterface*>(QQmlTypesExtensionInterface* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::QQmlTypesExtensionInterface>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionInterface> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlExtensionInterface_ptr(
                ptr.as_raw_ptr() as *mut crate::QQmlTypesExtensionInterface
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::QQmlTypesExtensionInterface>
    for crate::QQmlExtensionInterface
{
    /// Calls C++ function: <span style='color: green;'>```QQmlTypesExtensionInterface* static_cast<QQmlTypesExtensionInterface*>(QQmlExtensionInterface* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlExtensionInterface>,
    ) -> ::cpp_core::Ptr<crate::QQmlTypesExtensionInterface> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlTypesExtensionInterface_ptr(
                ptr.as_raw_ptr() as *mut crate::QQmlExtensionInterface,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlExtensionInterface {
    type Target = crate::QQmlTypesExtensionInterface;
    /// Calls C++ function: <span style='color: green;'>```QQmlTypesExtensionInterface* static_cast<QQmlTypesExtensionInterface*>(QQmlExtensionInterface* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &crate::QQmlTypesExtensionInterface {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlTypesExtensionInterface_ptr(
                    self as *const crate::QQmlExtensionInterface
                        as *mut crate::QQmlExtensionInterface,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlExtensionInterface> for crate::QQmlTypesExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionInterface* dynamic_cast<QQmlExtensionInterface*>(QQmlTypesExtensionInterface* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<crate::QQmlTypesExtensionInterface>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionInterface> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlExtensionInterface_ptr(
                ptr.as_raw_ptr() as *mut crate::QQmlTypesExtensionInterface
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlExtensionPlugin> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionPlugin* static_cast<QQmlExtensionPlugin*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionPlugin> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlExtensionPlugin_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlExtensionPlugin {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlExtensionPlugin* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlExtensionPlugin>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr6(
                ptr.as_raw_ptr() as *mut crate::QQmlExtensionPlugin
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlExtensionPlugin {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlExtensionPlugin* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr6(
                    self as *const crate::QQmlExtensionPlugin as *mut crate::QQmlExtensionPlugin,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlExtensionPlugin> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionPlugin* dynamic_cast<QQmlExtensionPlugin*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionPlugin> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlExtensionPlugin_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlExtensionPlugin> for crate::QQmlExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionPlugin* static_cast<QQmlExtensionPlugin*>(QQmlExtensionInterface* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::QQmlExtensionInterface>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionPlugin> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlExtensionPlugin_ptr1(
                ptr.as_raw_ptr() as *mut crate::QQmlExtensionInterface
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::QQmlExtensionInterface> for crate::QQmlExtensionPlugin {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionInterface* static_cast<QQmlExtensionInterface*>(QQmlExtensionPlugin* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlExtensionPlugin>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionInterface> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlExtensionInterface_ptr1(
                ptr.as_raw_ptr() as *mut crate::QQmlExtensionPlugin
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlExtensionPlugin> for crate::QQmlExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionPlugin* dynamic_cast<QQmlExtensionPlugin*>(QQmlExtensionInterface* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<crate::QQmlExtensionInterface>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionPlugin> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlExtensionPlugin_ptr1(
                ptr.as_raw_ptr() as *mut crate::QQmlExtensionInterface
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlExtensionPlugin> for crate::QQmlTypesExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionPlugin* static_cast<QQmlExtensionPlugin*>(QQmlTypesExtensionInterface* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<crate::QQmlTypesExtensionInterface>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionPlugin> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlExtensionPlugin_ptr2(
                ptr.as_raw_ptr() as *mut crate::QQmlTypesExtensionInterface
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<crate::QQmlTypesExtensionInterface> for crate::QQmlExtensionPlugin {
    /// Calls C++ function: <span style='color: green;'>```QQmlTypesExtensionInterface* static_cast<QQmlTypesExtensionInterface*>(QQmlExtensionPlugin* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlExtensionPlugin>,
    ) -> ::cpp_core::Ptr<crate::QQmlTypesExtensionInterface> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlTypesExtensionInterface_ptr1(
                ptr.as_raw_ptr() as *mut crate::QQmlExtensionPlugin,
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlExtensionPlugin> for crate::QQmlTypesExtensionInterface {
    /// Calls C++ function: <span style='color: green;'>```QQmlExtensionPlugin* dynamic_cast<QQmlExtensionPlugin*>(QQmlTypesExtensionInterface* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<crate::QQmlTypesExtensionInterface>,
    ) -> ::cpp_core::Ptr<crate::QQmlExtensionPlugin> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlExtensionPlugin_ptr2(
                ptr.as_raw_ptr() as *mut crate::QQmlTypesExtensionInterface
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlFileSelector> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlFileSelector* static_cast<QQmlFileSelector*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlFileSelector> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlFileSelector_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlFileSelector {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlFileSelector* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlFileSelector>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr7(
                ptr.as_raw_ptr() as *mut crate::QQmlFileSelector
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlFileSelector {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlFileSelector* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr7(
                    self as *const crate::QQmlFileSelector as *mut crate::QQmlFileSelector,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlFileSelector> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlFileSelector* dynamic_cast<QQmlFileSelector*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlFileSelector> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlFileSelector_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlInfo> for ::qt_core::QDebug {
    /// Calls C++ function: <span style='color: green;'>```QQmlInfo* static_cast<QQmlInfo*>(QDebug* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QDebug>,
    ) -> ::cpp_core::Ptr<crate::QQmlInfo> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlInfo_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QDebug
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QDebug> for crate::QQmlInfo {
    /// Calls C++ function: <span style='color: green;'>```QDebug* static_cast<QDebug*>(QQmlInfo* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlInfo>,
    ) -> ::cpp_core::Ptr<::qt_core::QDebug> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QDebug_ptr(
                ptr.as_raw_ptr() as *mut crate::QQmlInfo
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlInfo {
    type Target = ::qt_core::QDebug;
    /// Calls C++ function: <span style='color: green;'>```QDebug* static_cast<QDebug*>(QQmlInfo* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QDebug {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QDebug_ptr(
                    self as *const crate::QQmlInfo as *mut crate::QQmlInfo,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::StaticDowncast<crate::QQmlPropertyMap> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlPropertyMap* static_cast<QQmlPropertyMap*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlPropertyMap> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QQmlPropertyMap_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::QQmlPropertyMap {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlPropertyMap* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::QQmlPropertyMap>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr8(
                ptr.as_raw_ptr() as *mut crate::QQmlPropertyMap
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::QQmlPropertyMap {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(QQmlPropertyMap* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr8(
                    self as *const crate::QQmlPropertyMap as *mut crate::QQmlPropertyMap,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::QQmlPropertyMap> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```QQmlPropertyMap* dynamic_cast<QQmlPropertyMap*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::QQmlPropertyMap> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_QQmlPropertyMap_ptr(
                ptr.as_raw_ptr() as *mut ::qt_core::QObject
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::vector_ops::Data for crate::QPointerOfQObject {
    type Output = ::qt_core::QPtr<::qt_core::QObject>;
    /// <p>Returns the pointer to the object being guarded.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject* QPointer<QObject>::data() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#data">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the pointer to the object being guarded.</p>
    /// <p>This function was introduced in  Qt 4.4.</p></div>
    #[inline(always)]
    unsafe fn data(&self) -> ::qt_core::QPtr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_data(
                self as *const crate::QPointerOfQObject,
            )
        };
        ::qt_core::QPtr::from_raw(ffi_result)
    }
}

impl ::cpp_core::ops::Indirection for crate::QPointerOfQObject {
    type Output = ::cpp_core::Ref<::qt_core::QObject>;
    /// <p>Dereference operator; implements pointer semantics. Just use this operator as you would with a normal C++ pointer.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```QObject& QPointer<QObject>::operator*() const```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html#operator-2a">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Dereference operator; implements pointer semantics. Just use this operator as you would with a normal C++ pointer.</p></div>
    #[inline(always)]
    unsafe fn indirection(&self) -> ::cpp_core::Ref<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_operator_1(
                self as *const crate::QPointerOfQObject,
            )
        };
        ::cpp_core::Ref::from_raw(ffi_result).expect("attempted to construct a null Ref")
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ptr<::qt_core::QObject>> for crate::QPointerOfQObject {
    /// <p>Returns <code>true</code> if <i>c1</i> and <i>c2</i> are the same Unicode character; otherwise returns <code>false</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool operator==(const QPointer<QObject>& p, const QObject* o)```</span>.
    ///
    /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qchar.html#operator-eq-eq">C++ documentation</a> for <span style='color: green;'>```bool operator==(QChar c1, QChar c2)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>c1</i> and <i>c2</i> are the same Unicode character; otherwise returns <code>false</code>.</p></div>
    #[inline(always)]
    fn eq(&self, o: &::cpp_core::Ptr<::qt_core::QObject>) -> bool {
        unsafe {
            crate::__ffi::ctr_qt_qml_ffi_operator__45(
                self as *const crate::QPointerOfQObject,
                o.as_raw_ptr(),
            )
        }
    }
}

impl ::std::cmp::PartialEq<::cpp_core::Ref<crate::QPointerOfQObject>> for crate::QPointerOfQObject {
    /// <p>Returns <code>true</code> if <i>c1</i> and <i>c2</i> are the same Unicode character; otherwise returns <code>false</code>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```bool operator==(const QPointer<QObject>& p1, const QPointer<QObject>& p2)```</span>.
    ///
    /// Warning: no exact match found in C++ documentation. Below is the <a href="http://doc.qt.io/qt-5/qchar.html#operator-eq-eq">C++ documentation</a> for <span style='color: green;'>```bool operator==(QChar c1, QChar c2)```</span>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns <code>true</code> if <i>c1</i> and <i>c2</i> are the same Unicode character; otherwise returns <code>false</code>.</p></div>
    #[inline(always)]
    fn eq(&self, p2: &::cpp_core::Ref<crate::QPointerOfQObject>) -> bool {
        unsafe {
            crate::__ffi::ctr_qt_qml_ffi_operator__48(
                self as *const crate::QPointerOfQObject,
                p2.as_raw_ptr(),
            )
        }
    }
}

impl ::cpp_core::CppDeletable for crate::QPointerOfQObject {
    /// <p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    ///
    /// Calls C++ function: <span style='color: green;'>```[destructor] void QPointer<QObject>::~QPointer()```</span>.
    ///
    /// <a href="http://doc.qt.io/qt-5/qpointer.html">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>The <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> class is a template class that provides guarded pointers to <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    /// <p>A guarded pointer, <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;T&gt;, behaves like a normal C++ pointer <code>T *</code>, except that it is automatically set to 0 when the referenced object is destroyed (unlike normal C++ pointers, which become "dangling pointers" in such cases). <code>T</code> must be a subclass of <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>.</p>
    /// <p>Guarded pointers are useful whenever you need to store a pointer to a <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> that is owned by someone else, and therefore might be destroyed while you still hold a reference to it. You can safely test the pointer for validity.</p>
    /// <p>Note that Qt 5 introduces a slight change in behavior when using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>.</p>
    /// <ul>
    /// <li>When using <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> on a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> (or a subclass of <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>), previously the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> would be cleared by the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor. Now, the <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> is cleared by the <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a> destructor (since this is when <a href="http://doc.qt.io/qt-5/qweakpointer.html">QWeakPointer</a> objects are cleared). Any QPointers tracking a widget will <b>NOT</b> be cleared before the <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> destructor destroys the children for the widget being tracked.</li>
    /// </ul>
    /// <p>Qt also provides <a href="http://doc.qt.io/qt-5/qsharedpointer.html">QSharedPointer</a>, an implementation of a reference-counted shared pointer object, which can be used to maintain a collection of references to an individual pointer.</p>
    /// <p>Example:</p>
    /// <pre class="cpp">
    ///
    /// &#32;     <span class="type"><a href="http://doc.qt.io/qt-5/qpointer.html#QPointer">QPointer</a></span><span class="operator">&lt;</span><span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span><span class="operator">&gt;</span> label <span class="operator">=</span> <span class="keyword">new</span> <span class="type"><a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a></span>;
    /// &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>setText(<span class="string">"&amp;Status:"</span>);
    /// &#32;     ...
    /// &#32;     <span class="keyword">if</span> (label)
    /// &#32;   &#32;     label<span class="operator">-</span><span class="operator">&gt;</span>show();
    ///
    /// </pre>
    /// <p>If the <a href="http://doc.qt.io/qt-5/qlabel.html">QLabel</a> is deleted in the meantime, the <code>label</code> variable will hold 0 instead of an invalid address, and the last line will never be executed.</p>
    /// <p>The functions and operators available with a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> are the same as those available with a normal unguarded pointer, except the pointer arithmetic operators (<code>+</code>, <code>-</code>, <code>++</code>, and <code>--</code>), which are normally used only with arrays of objects.</p>
    /// <p>Use QPointers like normal pointers and you will not need to read this class documentation.</p>
    /// <p>For creating guarded pointers, you can construct or assign to them from a T* or from another guarded pointer of the same type. You can compare them with each other using operator==() and operator!=(), or test for 0 with <a href="http://doc.qt.io/qt-5/qpointer.html#isNull">isNull</a>(). You can dereference them using either the <code>*x</code> or the <code>x-&gt;member</code> notation.</p>
    /// <p>A guarded pointer will automatically cast to a <code>T</code> *, so you can freely mix guarded and unguarded pointers. This means that if you have a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a>&lt;<a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a>&gt;, you can pass it to a function that requires a <a href="http://doc.qt.io/qt-5/qwidget.html">QWidget</a> *. For this reason, it is of little value to declare functions to take a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> as a parameter; just use normal pointers. Use a <a href="http://doc.qt.io/qt-5/qpointer.html">QPointer</a> when you are storing a pointer over time.</p>
    /// <p>Note that class <code>T</code> must inherit <a href="http://doc.qt.io/qt-5/qobject.html">QObject</a>, or a compilation or link error will result.</p></div>
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_QPointer_QObject_dQPointer(
            self as *const crate::QPointerOfQObject as *mut crate::QPointerOfQObject,
        )
    }
}

impl ::cpp_core::CppDeletable for crate::SignalOfQStringQVariant {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref::~ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_dctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref(self as *const crate::SignalOfQStringQVariant as *mut crate::SignalOfQStringQVariant)
    }
}

impl ::cpp_core::CppDeletable for crate::SignalOfStatus {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status::~ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_dctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status(self as *const crate::SignalOfStatus as *mut crate::SignalOfStatus)
    }
}

impl ::cpp_core::CppDeletable for crate::SignalOfQListOfQQmlError {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref::~ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_dctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref(self as *const crate::SignalOfQListOfQQmlError as *mut crate::SignalOfQListOfQQmlError)
    }
}

impl ::cpp_core::CppDeletable for crate::SignalOfQObjectQUrl {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref::~ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_dctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref(self as *const crate::SignalOfQObjectQUrl as *mut crate::SignalOfQObjectQUrl)
    }
}

impl ::cpp_core::StaticDowncast<crate::SignalOfQStringQVariant> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref* static_cast<ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfQStringQVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SignalOfQStringQVariant {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SignalOfQStringQVariant>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr19(
                ptr.as_raw_ptr() as *mut crate::SignalOfQStringQVariant
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SignalOfQStringQVariant {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr19(
                    self as *const crate::SignalOfQStringQVariant
                        as *mut crate::SignalOfQStringQVariant,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SignalOfQStringQVariant> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref* dynamic_cast<ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfQStringQVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_signal_wrapper_QString_const_ref_QVariant_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::SignalOfStatus> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status* static_cast<ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfStatus> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SignalOfStatus {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SignalOfStatus>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr21(
                ptr.as_raw_ptr() as *mut crate::SignalOfStatus
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SignalOfStatus {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr21(
                    self as *const crate::SignalOfStatus as *mut crate::SignalOfStatus,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SignalOfStatus> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status* dynamic_cast<ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfStatus> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_signal_wrapper_QQmlComponent_Status_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::SignalOfQListOfQQmlError> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref* static_cast<ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfQListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SignalOfQListOfQQmlError {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SignalOfQListOfQQmlError>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr23(
                ptr.as_raw_ptr() as *mut crate::SignalOfQListOfQQmlError
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SignalOfQListOfQQmlError {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr23(
                    self as *const crate::SignalOfQListOfQQmlError
                        as *mut crate::SignalOfQListOfQQmlError,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SignalOfQListOfQQmlError> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref* dynamic_cast<ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfQListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_signal_wrapper_QList_QQmlError_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::SignalOfQObjectQUrl> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref* static_cast<ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfQObjectQUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SignalOfQObjectQUrl {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SignalOfQObjectQUrl>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr25(
                ptr.as_raw_ptr() as *mut crate::SignalOfQObjectQUrl
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SignalOfQObjectQUrl {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr25(
                    self as *const crate::SignalOfQObjectQUrl as *mut crate::SignalOfQObjectQUrl,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SignalOfQObjectQUrl> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref* dynamic_cast<ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SignalOfQObjectQUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_signal_wrapper_QObject_ptr_QUrl_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::CppDeletable for crate::SlotOfQObjectQUrl {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref::~ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_dctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref(self as *const crate::SlotOfQObjectQUrl as *mut crate::SlotOfQObjectQUrl)
    }
}

impl ::cpp_core::CppDeletable for crate::SlotOfStatus {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status::~ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_dctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status(self as *const crate::SlotOfStatus as *mut crate::SlotOfStatus)
    }
}

impl ::cpp_core::CppDeletable for crate::SlotOfQListOfQQmlError {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref::~ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_dctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref(self as *const crate::SlotOfQListOfQQmlError as *mut crate::SlotOfQListOfQQmlError)
    }
}

impl ::cpp_core::CppDeletable for crate::SlotOfQStringQVariant {
    /// Calls C++ function: <span style='color: green;'>```[destructor] void ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref::~ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref()```</span>.
    #[inline(always)]
    unsafe fn delete(&self) {
        crate::__ffi::ctr_qt_qml_ffi_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_dctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref(self as *const crate::SlotOfQStringQVariant as *mut crate::SlotOfQStringQVariant)
    }
}

impl ::cpp_core::StaticDowncast<crate::SlotOfQObjectQUrl> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref* static_cast<ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfQObjectQUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SlotOfQObjectQUrl {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SlotOfQObjectQUrl>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr26(
                ptr.as_raw_ptr() as *mut crate::SlotOfQObjectQUrl
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SlotOfQObjectQUrl {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr26(
                    self as *const crate::SlotOfQObjectQUrl as *mut crate::SlotOfQObjectQUrl,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SlotOfQObjectQUrl> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref* dynamic_cast<ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfQObjectQUrl> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_slot_wrapper_QObject_ptr_QUrl_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::SlotOfStatus> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status* static_cast<ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfStatus> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SlotOfStatus {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SlotOfStatus>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr27(
                ptr.as_raw_ptr() as *mut crate::SlotOfStatus
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SlotOfStatus {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr27(
                    self as *const crate::SlotOfStatus as *mut crate::SlotOfStatus,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SlotOfStatus> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status* dynamic_cast<ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfStatus> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_slot_wrapper_QQmlComponent_Status_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::SlotOfQListOfQQmlError> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref* static_cast<ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfQListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SlotOfQListOfQQmlError {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SlotOfQListOfQQmlError>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr28(
                ptr.as_raw_ptr() as *mut crate::SlotOfQListOfQQmlError
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SlotOfQListOfQQmlError {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr28(
                    self as *const crate::SlotOfQListOfQQmlError
                        as *mut crate::SlotOfQListOfQQmlError,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SlotOfQListOfQQmlError> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref* dynamic_cast<ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfQListOfQQmlError> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_slot_wrapper_QList_QQmlError_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticDowncast<crate::SlotOfQStringQVariant> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref* static_cast<ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_downcast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfQStringQVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::cpp_core::StaticUpcast<::qt_core::QObject> for crate::SlotOfQStringQVariant {
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref* ptr)```</span>.
    #[inline(always)]
    unsafe fn static_upcast(
        ptr: ::cpp_core::Ptr<crate::SlotOfQStringQVariant>,
    ) -> ::cpp_core::Ptr<::qt_core::QObject> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr29(
                ptr.as_raw_ptr() as *mut crate::SlotOfQStringQVariant
            )
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

impl ::std::ops::Deref for crate::SlotOfQStringQVariant {
    type Target = ::qt_core::QObject;
    /// Calls C++ function: <span style='color: green;'>```QObject* static_cast<QObject*>(ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref* ptr)```</span>.
    #[inline(always)]
    fn deref(&self) -> &::qt_core::QObject {
        let ffi_result = {
            unsafe {
                crate::__ffi::ctr_qt_qml_ffi_static_cast_QObject_ptr29(
                    self as *const crate::SlotOfQStringQVariant
                        as *mut crate::SlotOfQStringQVariant,
                )
            }
        };
        unsafe { ffi_result.as_ref() }.expect("Attempted to convert null pointer to reference")
    }
}

impl ::cpp_core::DynamicCast<crate::SlotOfQStringQVariant> for ::qt_core::QObject {
    /// Calls C++ function: <span style='color: green;'>```ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref* dynamic_cast<ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref*>(QObject* ptr)```</span>.
    #[inline(always)]
    unsafe fn dynamic_cast(
        ptr: ::cpp_core::Ptr<::qt_core::QObject>,
    ) -> ::cpp_core::Ptr<crate::SlotOfQStringQVariant> {
        let ffi_result = {
            crate::__ffi::ctr_qt_qml_ffi_dynamic_cast_ctr_qt_qml_ffi_slot_wrapper_QString_const_ref_QVariant_const_ref_ptr(ptr.as_raw_ptr() as *mut ::qt_core::QObject)
        };
        ::cpp_core::Ptr::from_raw(ffi_result)
    }
}

/// Calls C++ function: <span style='color: green;'>```unsigned int qHash(QObject * (*FN_PTR)(QObject *) func, unsigned int seed = …)```</span>.
#[inline(always)]
#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0")))
)]
#[cfg(any(
    any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0"),
    feature = "ritual_rustdoc"
))]
pub unsafe fn q_hash_option_fn_uint(
    func: ::std::option::Option<extern "C" fn(*mut ::qt_core::QObject) -> *mut ::qt_core::QObject>,
    seed: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint {
    crate::__ffi::ctr_qt_qml_ffi_qHash(func, seed)
}

/// Calls C++ function: <span style='color: green;'>```unsigned int qHash(const QQmlProperty& key)```</span>.
#[inline(always)]
pub unsafe fn q_hash_q_qml_property(
    key: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QQmlProperty>>,
) -> ::std::os::raw::c_uint {
    crate::__ffi::ctr_qt_qml_ffi_qHash1(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::QQmlProperty>>::cast_into(key).as_raw_ptr(),
    )
}

/// Calls C++ function: <span style='color: green;'>```unsigned int qHash(QObject * (*FN_PTR)(QObject *) func)```</span>.
#[inline(always)]
#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0")))
)]
#[cfg(any(
    any(cpp_lib_version = "5.13.0", cpp_lib_version = "5.14.0"),
    feature = "ritual_rustdoc"
))]
pub unsafe fn q_hash_option_fn(
    func: ::std::option::Option<extern "C" fn(*mut ::qt_core::QObject) -> *mut ::qt_core::QObject>,
) -> ::std::os::raw::c_uint {
    crate::__ffi::ctr_qt_qml_ffi_qHash8(func)
}

/// Calls C++ function: <span style='color: green;'>```QPointer<QObject> qPointerFromVariant<QObject>(const QVariant& variant)```</span>.
#[inline(always)]
pub unsafe fn q_pointer_from_variant_q_object(
    variant: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QVariant>>,
) -> ::cpp_core::CppBox<crate::QPointerOfQObject> {
    let ffi_result = {
        crate::__ffi::ctr_qt_qml_ffi_qPointerFromVariant_QObject(
            ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QVariant>>::cast_into(variant)
                .as_raw_ptr(),
        )
    };
    ::cpp_core::CppBox::from_raw(ffi_result).expect("attempted to construct a null CppBox")
}

/// Calls C++ function: <span style='color: green;'>```QJSEngine* qjsEngine(const QObject* arg1)```</span>.
#[inline(always)]
pub unsafe fn qjs_engine(
    arg1: impl ::cpp_core::CastInto<::cpp_core::Ptr<::qt_core::QObject>>,
) -> ::qt_core::QPtr<crate::QJSEngine> {
    let ffi_result = {
        crate::__ffi::ctr_qt_qml_ffi_qjsEngine(
            ::cpp_core::CastInto::<::cpp_core::Ptr<::qt_core::QObject>>::cast_into(arg1)
                .as_raw_ptr(),
        )
    };
    ::qt_core::QPtr::from_raw(ffi_result)
}

/// Calls C++ function: <span style='color: green;'>```bool qjsvalue_cast_helper(const QJSValue& value, int type, void* ptr)```</span>.
#[inline(always)]
pub unsafe fn qjsvalue_cast_helper(
    value: impl ::cpp_core::CastInto<::cpp_core::Ref<crate::QJSValue>>,
    type_: ::std::os::raw::c_int,
    ptr: *mut ::std::ffi::c_void,
) -> bool {
    crate::__ffi::ctr_qt_qml_ffi_qjsvalue_cast_helper(
        ::cpp_core::CastInto::<::cpp_core::Ref<crate::QJSValue>>::cast_into(value).as_raw_ptr(),
        type_,
        ptr,
    )
}

/// <p>Clears all stored type registrations, such as those produced with <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType">qmlRegisterType</a>().</p>
///
/// Calls C++ function: <span style='color: green;'>```void qmlClearTypeRegistrations()```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlClearTypeRegistrations">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Clears all stored type registrations, such as those produced with <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType">qmlRegisterType</a>().</p>
/// <p>Do not call this function while a <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> exists or behavior will be undefined. Any existing QQmlEngines must be deleted before calling this function. This function only affects the application global cache. Delete the <a href="http://doc.qt.io/qt-5/qqmlengine.html">QQmlEngine</a> to clear all cached data relating to that engine.</p></div>
#[inline(always)]
pub unsafe fn qml_clear_type_registrations() {
    crate::__ffi::ctr_qt_qml_ffi_qmlClearTypeRegistrations()
}

/// <p>This function protects a module from having types registered into it. This can be used to prevent other plugins from injecting types into your module. It can also be a performance improvement, as it allows the engine to skip checking for the possibility of new types or plugins when this import is reached.</p>
///
/// Calls C++ function: <span style='color: green;'>```bool qmlProtectModule(const char* uri, int majVersion)```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlProtectModule">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function protects a module from having types registered into it. This can be used to prevent other plugins from injecting types into your module. It can also be a performance improvement, as it allows the engine to skip checking for the possibility of new types or plugins when this import is reached.</p>
/// <p>The performance benefit is primarily seen when registering application specific types from within the application instead of through a plugin. Using qmlProtectModule allows the engine to skip checking for a plugin when that uri is imported, which can be noticeable with slow file systems.</p>
/// <p>After this function is called, any attempt to register C++ types into this uri, major version combination will lead to a runtime error. Call this after you have registered all of your types with the engine.</p>
/// <p>Returns true if the module with <i>uri</i> as a <a href="http://doc.qt.io/qt-5/qtqml-modules-identifiedmodules.html">module identifier</a> and <i>majVersion</i> as a major version number was found and locked, otherwise returns false. The module must contain exported types in order to be found.</p></div>
#[inline(always)]
pub unsafe fn qml_protect_module(
    uri: *const ::std::os::raw::c_char,
    maj_version: ::std::os::raw::c_int,
) -> bool {
    crate::__ffi::ctr_qt_qml_ffi_qmlProtectModule(uri, maj_version)
}

/// <p>This function registers a module in a particular <i>uri</i> with a version specified in <i>versionMajor</i> and <i>versionMinor</i>.</p>
///
/// Calls C++ function: <span style='color: green;'>```void qmlRegisterModule(const char* uri, int versionMajor, int versionMinor)```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterModule">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function registers a module in a particular <i>uri</i> with a version specified in <i>versionMajor</i> and <i>versionMinor</i>.</p>
/// <p>This can be used to make a certain module version available, even if no types are registered for that version. This is particularly useful for keeping the versions of related modules in sync.</p>
/// <p>This function was introduced in  Qt 5.9.</p></div>
#[inline(always)]
pub unsafe fn qml_register_module(
    uri: *const ::std::os::raw::c_char,
    version_major: ::std::os::raw::c_int,
    version_minor: ::std::os::raw::c_int,
) {
    crate::__ffi::ctr_qt_qml_ffi_qmlRegisterModule(uri, version_major, version_minor)
}

/// <p>This function may be used to register a singleton type with the name <i>qmlName</i>, in the library imported from <i>uri</i> having the version number composed from <i>versionMajor</i> and <i>versionMinor</i>. The type is defined by the QML file located at <i>url</i>. The url must be an absolute URL, i.e. url.isRelative() == false.</p>
///
/// Calls C++ function: <span style='color: green;'>```int qmlRegisterSingletonType(const QUrl& url, const char* uri, int versionMajor, int versionMinor, const char* qmlName)```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterSingletonType-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function may be used to register a singleton type with the name <i>qmlName</i>, in the library imported from <i>uri</i> having the version number composed from <i>versionMajor</i> and <i>versionMinor</i>. The type is defined by the QML file located at <i>url</i>. The url must be an absolute URL, i.e. url.isRelative() == false.</p>
/// <p>In addition the type's QML file must have pragma Singleton statement among its import statements.</p>
/// <p>A singleton type may be referenced via the type name with which it was registered, and this typename may be used as the target in a <a href="http://doc.qt.io/qt-5/qml-qtqml-connections.html">Connections</a> type or otherwise used as any other type id would. One exception to this is that a singleton type property may not be aliased (because the singleton type name does not identify an object within the same component as any other item).</p>
/// <p>Usage:</p>
/// <pre class="qml">
///
///   <span class="comment">// First, define your QML singleton type which provides the functionality.</span>
///   pragma Singleton
///   import QtQuick 2.0
///   <span class="type">Item</span> {
/// &#32;     property <span class="type">int</span> <span class="name">testProp1</span>: <span class="number">125</span>
///   }
///
/// </pre>
/// <pre class="cpp">
///
///   <span class="comment">// Second, register the QML singleton type by calling this function in an initialization function.</span>
///   qmlRegisterSingletonType(<span class="type"><a href="http://doc.qt.io/qt-5/qurl.html">QUrl</a></span>(<span class="string">"file:///absolute/path/SingletonType.qml"</span>)<span class="operator">,</span> <span class="string">"Qt.example.qobjectSingleton"</span><span class="operator">,</span> <span class="number">1</span><span class="operator">,</span> <span class="number">0</span><span class="operator">,</span> <span class="string">"RegisteredSingleton"</span>);
///
/// </pre>
/// <p>In order to use the registered singleton type in QML, you must import the singleton type.</p>
/// <pre class="qml">
///
///   import QtQuick 2.0
///   import Qt.example.qobjectSingleton 1.0
///   <span class="type">Item</span> {
/// &#32;     <span class="name">id</span>: <span class="name">root</span>
/// &#32;     property <span class="type">int</span> <span class="name">someValue</span>: <span class="name">RegisteredSingleton</span>.<span class="name">testProp1</span>
///   }
///
/// </pre>
/// <p>It is also possible to have QML singleton types registered without using the <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterSingletonType">qmlRegisterSingletonType</a> function. That can be done by adding a pragma Singleton statement among the imports of the type's QML file. In addition the type must be defined in a qmldir file with a singleton keyword and the qmldir must be imported by the QML files using the singleton.</p></div>
#[inline(always)]
pub unsafe fn qml_register_singleton_type(
    url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    uri: *const ::std::os::raw::c_char,
    version_major: ::std::os::raw::c_int,
    version_minor: ::std::os::raw::c_int,
    qml_name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_qt_qml_ffi_qmlRegisterSingletonType1(
        ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
        uri,
        version_major,
        version_minor,
        qml_name,
    )
}

/// <p>This function registers a type in the QML system with the name <i>qmlName</i>, in the library imported from <i>uri</i> having the version number composed from <i>versionMajor</i> and <i>versionMinor</i>. The type is defined by the QML file located at <i>url</i>. The url must be an absolute URL, i.e. url.isRelative() == false.</p>
///
/// Calls C++ function: <span style='color: green;'>```int qmlRegisterType(const QUrl& url, const char* uri, int versionMajor, int versionMinor, const char* qmlName)```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType-2">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function registers a type in the QML system with the name <i>qmlName</i>, in the library imported from <i>uri</i> having the version number composed from <i>versionMajor</i> and <i>versionMinor</i>. The type is defined by the QML file located at <i>url</i>. The url must be an absolute URL, i.e. url.isRelative() == false.</p>
/// <p>Normally QML files can be loaded as types directly from other QML files, or using a qmldir file. This function allows registration of files to types from C++ code, such as when the type mapping needs to be procedurally determined at startup.</p>
/// <p>Returns -1 if the registration was not successful.</p></div>
#[inline(always)]
pub unsafe fn qml_register_type(
    url: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QUrl>>,
    uri: *const ::std::os::raw::c_char,
    version_major: ::std::os::raw::c_int,
    version_minor: ::std::os::raw::c_int,
    qml_name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_qt_qml_ffi_qmlRegisterType(
        ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QUrl>>::cast_into(url).as_raw_ptr(),
        uri,
        version_major,
        version_minor,
        qml_name,
    )
}

/// <p>This function registers a type in the QML system with the name <i>qmlName</i>, in the type namespace imported from <i>uri</i> having the version number composed from <i>versionMajor</i> and <i>versionMinor</i>, but any attempt to instantiate the type will produce the given error <i>message</i>.</p>
///
/// Calls C++ function: <span style='color: green;'>```int qmlRegisterTypeNotAvailable(const char* uri, int versionMajor, int versionMinor, const char* qmlName, const QString& message)```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterTypeNotAvailable">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function registers a type in the QML system with the name <i>qmlName</i>, in the type namespace imported from <i>uri</i> having the version number composed from <i>versionMajor</i> and <i>versionMinor</i>, but any attempt to instantiate the type will produce the given error <i>message</i>.</p>
/// <p>Normally, the types exported by a plugin should be fixed. However, if a C++ type is not available, you should at least "reserve" the QML type name, and give the user of the unavailable type a meaningful error message.</p>
/// <p>Returns the QML type id.</p>
/// <p>Example:</p>
/// <pre class="cpp">
///
///   <span class="preprocessor">#ifdef NO_GAMES_ALLOWED</span>
///   qmlRegisterTypeNotAvailable(<span class="string">"MinehuntCore"</span><span class="operator">,</span> <span class="number">0</span><span class="operator">,</span> <span class="number">1</span><span class="operator">,</span> <span class="string">"Game"</span><span class="operator">,</span> <span class="string">"Get back to work, slacker!"</span>);
///   <span class="preprocessor">#else</span>
///   qmlRegisterType<span class="operator">&lt;</span>MinehuntGame<span class="operator">&gt;</span>(<span class="string">"MinehuntCore"</span><span class="operator">,</span> <span class="number">0</span><span class="operator">,</span> <span class="number">1</span><span class="operator">,</span> <span class="string">"Game"</span>);
///   <span class="preprocessor">#endif</span>
///
/// </pre>
/// <p>This will cause any QML which imports the "MinehuntCore" type namespace and attempts to use the type to produce an error message:</p>
/// <pre class="cpp">
///
///   fun<span class="operator">.</span>qml: Get back to work<span class="operator">,</span> slacker<span class="operator">!</span>
/// &#32;    Game {
/// &#32;    <span class="operator">^</span>
///
/// </pre>
/// <p>Without this, a generic "Game is not a type" message would be given.</p>
/// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterUncreatableType">qmlRegisterUncreatableType</a>().</p></div>
#[inline(always)]
pub unsafe fn qml_register_type_not_available(
    uri: *const ::std::os::raw::c_char,
    version_major: ::std::os::raw::c_int,
    version_minor: ::std::os::raw::c_int,
    qml_name: *const ::std::os::raw::c_char,
    message: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_qt_qml_ffi_qmlRegisterTypeNotAvailable(
        uri,
        version_major,
        version_minor,
        qml_name,
        ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(message)
            .as_raw_ptr(),
    )
}

/// <p>This function registers the <i>staticMetaObject</i> and its extension in the QML system with the name <i>qmlName</i> in the library imported from <i>uri</i> having version number composed from <i>versionMajor</i> and <i>versionMinor</i>.</p>
///
/// Calls C++ function: <span style='color: green;'>```int qmlRegisterUncreatableMetaObject(const QMetaObject& staticMetaObject, const char* uri, int versionMajor, int versionMinor, const char* qmlName, const QString& reason)```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterUncreatableMetaObject">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>This function registers the <i>staticMetaObject</i> and its extension in the QML system with the name <i>qmlName</i> in the library imported from <i>uri</i> having version number composed from <i>versionMajor</i> and <i>versionMinor</i>.</p>
/// <p>An instance of the meta object cannot be created. An error message with the given <i>reason</i> is printed if the user attempts to create it.</p>
/// <p>This function is useful for registering Q_NAMESPACE namespaces.</p>
/// <p>Returns the QML type id.</p>
/// <p>For example:</p>
/// <pre class="cpp">
///
///   <span class="keyword">namespace</span> MyNamespace {
/// &#32;   Q_NAMESPACE
/// &#32;   <span class="keyword">enum</span> MyEnum {
/// &#32;   &#32;   Key1<span class="operator">,</span>
/// &#32;   &#32;   Key2<span class="operator">,</span>
/// &#32;   };
/// &#32;   Q_ENUMS(MyEnum)
///   }
///
///   <span class="comment">//...</span>
///   qmlRegisterUncreatableMetaObject(MyNamespace<span class="operator">::</span>staticMetaObject<span class="operator">,</span> <span class="string">"io.qt"</span><span class="operator">,</span> <span class="number">1</span><span class="operator">,</span> <span class="number">0</span><span class="operator">,</span> <span class="string">"MyNamespace"</span><span class="operator">,</span> <span class="string">"Access to enums &amp; flags only"</span>);
///
/// </pre>
/// <p>On the QML side, you can now use the registered enums:</p>
/// <pre class="cpp">
///
///   Component<span class="operator">.</span>onCompleted: console<span class="operator">.</span>log(MyNamespace<span class="operator">.</span>Key2)
///
/// </pre>
/// <p>This function was introduced in  Qt 5.8.</p></div>
#[inline(always)]
pub unsafe fn qml_register_uncreatable_meta_object(
    static_meta_object: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QMetaObject>>,
    uri: *const ::std::os::raw::c_char,
    version_major: ::std::os::raw::c_int,
    version_minor: ::std::os::raw::c_int,
    qml_name: *const ::std::os::raw::c_char,
    reason: impl ::cpp_core::CastInto<::cpp_core::Ref<::qt_core::QString>>,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_qt_qml_ffi_qmlRegisterUncreatableMetaObject(
        ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QMetaObject>>::cast_into(
            static_meta_object,
        )
        .as_raw_ptr(),
        uri,
        version_major,
        version_minor,
        qml_name,
        ::cpp_core::CastInto::<::cpp_core::Ref<::qt_core::QString>>::cast_into(reason).as_raw_ptr(),
    )
}

/// <p>Returns the QML type id of a type that was registered with the name <i>qmlName</i> in a particular <i>uri</i> and a version specified in <i>versionMajor</i> and <i>versionMinor</i>.</p>
///
/// Calls C++ function: <span style='color: green;'>```int qmlTypeId(const char* uri, int versionMajor, int versionMinor, const char* qmlName)```</span>.
///
/// <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlTypeId">C++ documentation</a>:<div style='border: 1px solid #5CFF95; background: #D6FFE4; padding: 16px;'><p>Returns the QML type id of a type that was registered with the name <i>qmlName</i> in a particular <i>uri</i> and a version specified in <i>versionMajor</i> and <i>versionMinor</i>.</p>
/// <p>This function returns the same value as the QML type registration functions such as <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType">qmlRegisterType</a>() and <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterSingletonType">qmlRegisterSingletonType</a>().</p>
/// <p>If <i>qmlName</i>, <i>uri</i> and <i>versionMajor</i> match a registered type, but the specified minor version in <i>versionMinor</i> is higher, then the id of the type with the closest minor version is returned.</p>
/// <p>Returns -1 if no matching type was found or one of the given parameters was invalid.</p>
/// <p>This function was introduced in  Qt 5.12.</p>
/// <p><b>See also </b><a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterType">qmlRegisterType</a>() and <a href="http://doc.qt.io/qt-5/qqmlengine.html#qmlRegisterSingletonType">qmlRegisterSingletonType</a>().</p></div>
#[inline(always)]
#[cfg_attr(
    feature = "ritual_rustdoc_nightly",
    doc(cfg(any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    )))
)]
#[cfg(any(
    any(
        cpp_lib_version = "5.13.0",
        cpp_lib_version = "5.12.2",
        cpp_lib_version = "5.14.0"
    ),
    feature = "ritual_rustdoc"
))]
pub unsafe fn qml_type_id(
    uri: *const ::std::os::raw::c_char,
    version_major: ::std::os::raw::c_int,
    version_minor: ::std::os::raw::c_int,
    qml_name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int {
    crate::__ffi::ctr_qt_qml_ffi_qmlTypeId(uri, version_major, version_minor, qml_name)
}