webkit2gtk_webextension_sys/

lib.rs

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

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(feature = "dox", feature(doc_cfg))]

#[allow(unused_imports)]
use libc::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
    intptr_t, size_t, ssize_t, uintptr_t, FILE,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type WebKitConsoleMessageLevel = c_int;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_INFO: WebKitConsoleMessageLevel = 0;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_LOG: WebKitConsoleMessageLevel = 1;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_WARNING: WebKitConsoleMessageLevel = 2;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_ERROR: WebKitConsoleMessageLevel = 3;
pub const WEBKIT_CONSOLE_MESSAGE_LEVEL_DEBUG: WebKitConsoleMessageLevel = 4;

pub type WebKitConsoleMessageSource = c_int;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_JAVASCRIPT: WebKitConsoleMessageSource = 0;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_NETWORK: WebKitConsoleMessageSource = 1;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_CONSOLE_API: WebKitConsoleMessageSource = 2;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_SECURITY: WebKitConsoleMessageSource = 3;
pub const WEBKIT_CONSOLE_MESSAGE_SOURCE_OTHER: WebKitConsoleMessageSource = 4;

pub type WebKitContextMenuAction = c_int;
pub const WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION: WebKitContextMenuAction = 0;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK: WebKitContextMenuAction = 1;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK_IN_NEW_WINDOW: WebKitContextMenuAction = 2;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_LINK_TO_DISK: WebKitContextMenuAction = 3;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_LINK_TO_CLIPBOARD: WebKitContextMenuAction = 4;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_IMAGE_IN_NEW_WINDOW: WebKitContextMenuAction = 5;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_IMAGE_TO_DISK: WebKitContextMenuAction = 6;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_IMAGE_TO_CLIPBOARD: WebKitContextMenuAction = 7;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_IMAGE_URL_TO_CLIPBOARD: WebKitContextMenuAction = 8;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_FRAME_IN_NEW_WINDOW: WebKitContextMenuAction = 9;
pub const WEBKIT_CONTEXT_MENU_ACTION_GO_BACK: WebKitContextMenuAction = 10;
pub const WEBKIT_CONTEXT_MENU_ACTION_GO_FORWARD: WebKitContextMenuAction = 11;
pub const WEBKIT_CONTEXT_MENU_ACTION_STOP: WebKitContextMenuAction = 12;
pub const WEBKIT_CONTEXT_MENU_ACTION_RELOAD: WebKitContextMenuAction = 13;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY: WebKitContextMenuAction = 14;
pub const WEBKIT_CONTEXT_MENU_ACTION_CUT: WebKitContextMenuAction = 15;
pub const WEBKIT_CONTEXT_MENU_ACTION_PASTE: WebKitContextMenuAction = 16;
pub const WEBKIT_CONTEXT_MENU_ACTION_DELETE: WebKitContextMenuAction = 17;
pub const WEBKIT_CONTEXT_MENU_ACTION_SELECT_ALL: WebKitContextMenuAction = 18;
pub const WEBKIT_CONTEXT_MENU_ACTION_INPUT_METHODS: WebKitContextMenuAction = 19;
pub const WEBKIT_CONTEXT_MENU_ACTION_UNICODE: WebKitContextMenuAction = 20;
pub const WEBKIT_CONTEXT_MENU_ACTION_SPELLING_GUESS: WebKitContextMenuAction = 21;
pub const WEBKIT_CONTEXT_MENU_ACTION_NO_GUESSES_FOUND: WebKitContextMenuAction = 22;
pub const WEBKIT_CONTEXT_MENU_ACTION_IGNORE_SPELLING: WebKitContextMenuAction = 23;
pub const WEBKIT_CONTEXT_MENU_ACTION_LEARN_SPELLING: WebKitContextMenuAction = 24;
pub const WEBKIT_CONTEXT_MENU_ACTION_IGNORE_GRAMMAR: WebKitContextMenuAction = 25;
pub const WEBKIT_CONTEXT_MENU_ACTION_FONT_MENU: WebKitContextMenuAction = 26;
pub const WEBKIT_CONTEXT_MENU_ACTION_BOLD: WebKitContextMenuAction = 27;
pub const WEBKIT_CONTEXT_MENU_ACTION_ITALIC: WebKitContextMenuAction = 28;
pub const WEBKIT_CONTEXT_MENU_ACTION_UNDERLINE: WebKitContextMenuAction = 29;
pub const WEBKIT_CONTEXT_MENU_ACTION_OUTLINE: WebKitContextMenuAction = 30;
pub const WEBKIT_CONTEXT_MENU_ACTION_INSPECT_ELEMENT: WebKitContextMenuAction = 31;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_VIDEO_IN_NEW_WINDOW: WebKitContextMenuAction = 32;
pub const WEBKIT_CONTEXT_MENU_ACTION_OPEN_AUDIO_IN_NEW_WINDOW: WebKitContextMenuAction = 33;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_VIDEO_LINK_TO_CLIPBOARD: WebKitContextMenuAction = 34;
pub const WEBKIT_CONTEXT_MENU_ACTION_COPY_AUDIO_LINK_TO_CLIPBOARD: WebKitContextMenuAction = 35;
pub const WEBKIT_CONTEXT_MENU_ACTION_TOGGLE_MEDIA_CONTROLS: WebKitContextMenuAction = 36;
pub const WEBKIT_CONTEXT_MENU_ACTION_TOGGLE_MEDIA_LOOP: WebKitContextMenuAction = 37;
pub const WEBKIT_CONTEXT_MENU_ACTION_ENTER_VIDEO_FULLSCREEN: WebKitContextMenuAction = 38;
pub const WEBKIT_CONTEXT_MENU_ACTION_MEDIA_PLAY: WebKitContextMenuAction = 39;
pub const WEBKIT_CONTEXT_MENU_ACTION_MEDIA_PAUSE: WebKitContextMenuAction = 40;
pub const WEBKIT_CONTEXT_MENU_ACTION_MEDIA_MUTE: WebKitContextMenuAction = 41;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_VIDEO_TO_DISK: WebKitContextMenuAction = 42;
pub const WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_AUDIO_TO_DISK: WebKitContextMenuAction = 43;
pub const WEBKIT_CONTEXT_MENU_ACTION_INSERT_EMOJI: WebKitContextMenuAction = 44;
pub const WEBKIT_CONTEXT_MENU_ACTION_PASTE_AS_PLAIN_TEXT: WebKitContextMenuAction = 45;
pub const WEBKIT_CONTEXT_MENU_ACTION_CUSTOM: WebKitContextMenuAction = 10000;

pub type WebKitFormSubmissionStep = c_int;
pub const WEBKIT_FORM_SUBMISSION_WILL_SEND_DOM_EVENT: WebKitFormSubmissionStep = 0;
pub const WEBKIT_FORM_SUBMISSION_WILL_COMPLETE: WebKitFormSubmissionStep = 1;

pub type WebKitUserMessageError = c_int;
pub const WEBKIT_USER_MESSAGE_UNHANDLED_MESSAGE: WebKitUserMessageError = 0;

// Constants
pub const WEBKIT_DOM_CSS_RULE_CHARSET_RULE: c_int = 2;
pub const WEBKIT_DOM_CSS_RULE_FONT_FACE_RULE: c_int = 5;
pub const WEBKIT_DOM_CSS_RULE_IMPORT_RULE: c_int = 3;
pub const WEBKIT_DOM_CSS_RULE_MEDIA_RULE: c_int = 4;
pub const WEBKIT_DOM_CSS_RULE_PAGE_RULE: c_int = 6;
pub const WEBKIT_DOM_CSS_RULE_STYLE_RULE: c_int = 1;
pub const WEBKIT_DOM_CSS_RULE_UNKNOWN_RULE: c_int = 0;
pub const WEBKIT_DOM_CSS_VALUE_CSS_CUSTOM: c_int = 3;
pub const WEBKIT_DOM_CSS_VALUE_CSS_INHERIT: c_int = 0;
pub const WEBKIT_DOM_CSS_VALUE_CSS_PRIMITIVE_VALUE: c_int = 1;
pub const WEBKIT_DOM_CSS_VALUE_CSS_VALUE_LIST: c_int = 2;
pub const WEBKIT_DOM_ELEMENT_ALLOW_KEYBOARD_INPUT: c_int = 1;
pub const WEBKIT_DOM_EVENT_AT_TARGET: c_int = 2;
pub const WEBKIT_DOM_EVENT_BLUR: c_int = 8192;
pub const WEBKIT_DOM_EVENT_BUBBLING_PHASE: c_int = 3;
pub const WEBKIT_DOM_EVENT_CAPTURING_PHASE: c_int = 1;
pub const WEBKIT_DOM_EVENT_CHANGE: c_int = 32768;
pub const WEBKIT_DOM_EVENT_CLICK: c_int = 64;
pub const WEBKIT_DOM_EVENT_DBLCLICK: c_int = 128;
pub const WEBKIT_DOM_EVENT_DRAGDROP: c_int = 2048;
pub const WEBKIT_DOM_EVENT_FOCUS: c_int = 4096;
pub const WEBKIT_DOM_EVENT_KEYDOWN: c_int = 256;
pub const WEBKIT_DOM_EVENT_KEYPRESS: c_int = 1024;
pub const WEBKIT_DOM_EVENT_KEYUP: c_int = 512;
pub const WEBKIT_DOM_EVENT_MOUSEDOWN: c_int = 1;
pub const WEBKIT_DOM_EVENT_MOUSEDRAG: c_int = 32;
pub const WEBKIT_DOM_EVENT_MOUSEMOVE: c_int = 16;
pub const WEBKIT_DOM_EVENT_MOUSEOUT: c_int = 8;
pub const WEBKIT_DOM_EVENT_MOUSEOVER: c_int = 4;
pub const WEBKIT_DOM_EVENT_MOUSEUP: c_int = 2;
pub const WEBKIT_DOM_EVENT_NONE: c_int = 0;
pub const WEBKIT_DOM_EVENT_SELECT: c_int = 16384;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_LEFT: c_int = 1;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_NUMPAD: c_int = 3;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_RIGHT: c_int = 2;
pub const WEBKIT_DOM_KEYBOARD_EVENT_KEY_LOCATION_STANDARD: c_int = 0;
pub const WEBKIT_DOM_NODE_ATTRIBUTE_NODE: c_int = 2;
pub const WEBKIT_DOM_NODE_CDATA_SECTION_NODE: c_int = 4;
pub const WEBKIT_DOM_NODE_COMMENT_NODE: c_int = 8;
pub const WEBKIT_DOM_NODE_DOCUMENT_FRAGMENT_NODE: c_int = 11;
pub const WEBKIT_DOM_NODE_DOCUMENT_NODE: c_int = 9;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_CONTAINED_BY: c_int = 16;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_CONTAINS: c_int = 8;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_DISCONNECTED: c_int = 1;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_FOLLOWING: c_int = 4;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: c_int = 32;
pub const WEBKIT_DOM_NODE_DOCUMENT_POSITION_PRECEDING: c_int = 2;
pub const WEBKIT_DOM_NODE_DOCUMENT_TYPE_NODE: c_int = 10;
pub const WEBKIT_DOM_NODE_ELEMENT_NODE: c_int = 1;
pub const WEBKIT_DOM_NODE_ENTITY_NODE: c_int = 6;
pub const WEBKIT_DOM_NODE_ENTITY_REFERENCE_NODE: c_int = 5;
pub const WEBKIT_DOM_NODE_FILTER_ACCEPT: c_int = 1;
pub const WEBKIT_DOM_NODE_FILTER_REJECT: c_int = 2;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ALL: c_uint = 4294967295;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ATTRIBUTE: c_int = 2;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_CDATA_SECTION: c_int = 8;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_COMMENT: c_int = 128;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_DOCUMENT: c_int = 256;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_DOCUMENT_FRAGMENT: c_int = 1024;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_DOCUMENT_TYPE: c_int = 512;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ELEMENT: c_int = 1;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ENTITY: c_int = 32;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_ENTITY_REFERENCE: c_int = 16;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_NOTATION: c_int = 2048;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_PROCESSING_INSTRUCTION: c_int = 64;
pub const WEBKIT_DOM_NODE_FILTER_SHOW_TEXT: c_int = 4;
pub const WEBKIT_DOM_NODE_FILTER_SKIP: c_int = 3;
pub const WEBKIT_DOM_NODE_PROCESSING_INSTRUCTION_NODE: c_int = 7;
pub const WEBKIT_DOM_NODE_TEXT_NODE: c_int = 3;
pub const WEBKIT_DOM_RANGE_END_TO_END: c_int = 2;
pub const WEBKIT_DOM_RANGE_END_TO_START: c_int = 3;
pub const WEBKIT_DOM_RANGE_NODE_AFTER: c_int = 1;
pub const WEBKIT_DOM_RANGE_NODE_BEFORE: c_int = 0;
pub const WEBKIT_DOM_RANGE_NODE_BEFORE_AND_AFTER: c_int = 2;
pub const WEBKIT_DOM_RANGE_NODE_INSIDE: c_int = 3;
pub const WEBKIT_DOM_RANGE_START_TO_END: c_int = 1;
pub const WEBKIT_DOM_RANGE_START_TO_START: c_int = 0;
pub const WEBKIT_DOM_XPATH_RESULT_ANY_TYPE: c_int = 0;
pub const WEBKIT_DOM_XPATH_RESULT_ANY_UNORDERED_NODE_TYPE: c_int = 8;
pub const WEBKIT_DOM_XPATH_RESULT_BOOLEAN_TYPE: c_int = 3;
pub const WEBKIT_DOM_XPATH_RESULT_FIRST_ORDERED_NODE_TYPE: c_int = 9;
pub const WEBKIT_DOM_XPATH_RESULT_NUMBER_TYPE: c_int = 1;
pub const WEBKIT_DOM_XPATH_RESULT_ORDERED_NODE_ITERATOR_TYPE: c_int = 5;
pub const WEBKIT_DOM_XPATH_RESULT_ORDERED_NODE_SNAPSHOT_TYPE: c_int = 7;
pub const WEBKIT_DOM_XPATH_RESULT_STRING_TYPE: c_int = 2;
pub const WEBKIT_DOM_XPATH_RESULT_UNORDERED_NODE_ITERATOR_TYPE: c_int = 4;
pub const WEBKIT_DOM_XPATH_RESULT_UNORDERED_NODE_SNAPSHOT_TYPE: c_int = 6;

// Flags
pub type WebKitHitTestResultContext = c_uint;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT: WebKitHitTestResultContext = 2;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK: WebKitHitTestResultContext = 4;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE: WebKitHitTestResultContext = 8;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA: WebKitHitTestResultContext = 16;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE: WebKitHitTestResultContext = 32;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_SCROLLBAR: WebKitHitTestResultContext = 64;
pub const WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION: WebKitHitTestResultContext = 128;

// Callbacks
pub type WebKitWebExtensionInitializeFunction =
    Option<unsafe extern "C" fn(*mut WebKitWebExtension)>;
pub type WebKitWebExtensionInitializeWithUserDataFunction =
    Option<unsafe extern "C" fn(*mut WebKitWebExtension, *const glib::GVariant)>;

// Records
#[repr(C)]
pub struct WebKitConsoleMessage {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for WebKitConsoleMessage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitConsoleMessage @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitContextMenuClass {
    pub parent_class: gobject::GObjectClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitContextMenuClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitContextMenuClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitContextMenuItemClass {
    pub parent_class: gobject::GInitiallyUnownedClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitContextMenuItemClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitContextMenuItemClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitContextMenuItemPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitContextMenuItemPrivate = *mut _WebKitContextMenuItemPrivate;

#[repr(C)]
pub struct _WebKitContextMenuPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitContextMenuPrivate = *mut _WebKitContextMenuPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMAttrClass {
    pub parent_class: WebKitDOMNodeClass,
}

impl ::std::fmt::Debug for WebKitDOMAttrClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMAttrClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMBlobClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMBlobClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMBlobClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCDATASectionClass {
    pub parent_class: WebKitDOMTextClass,
}

impl ::std::fmt::Debug for WebKitDOMCDATASectionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCDATASectionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSRuleClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMCSSRuleClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSRuleClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSRuleListClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMCSSRuleListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSRuleListClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSStyleDeclarationClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMCSSStyleDeclarationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSStyleDeclarationClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSStyleSheetClass {
    pub parent_class: WebKitDOMStyleSheetClass,
}

impl ::std::fmt::Debug for WebKitDOMCSSStyleSheetClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSStyleSheetClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSValueClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMCSSValueClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSValueClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCharacterDataClass {
    pub parent_class: WebKitDOMNodeClass,
}

impl ::std::fmt::Debug for WebKitDOMCharacterDataClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCharacterDataClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMClientRectClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMClientRectClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMClientRectClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMClientRectListClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMClientRectListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMClientRectListClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCommentClass {
    pub parent_class: WebKitDOMCharacterDataClass,
}

impl ::std::fmt::Debug for WebKitDOMCommentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCommentClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMImplementationClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMDOMImplementationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMImplementationClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMSelectionClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMDOMSelectionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMSelectionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMTokenListClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMDOMTokenListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMTokenListClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMWindowClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMDOMWindowClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMWindowClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDocumentClass {
    pub parent_class: WebKitDOMNodeClass,
}

impl ::std::fmt::Debug for WebKitDOMDocumentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDocumentClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDocumentFragmentClass {
    pub parent_class: WebKitDOMNodeClass,
}

impl ::std::fmt::Debug for WebKitDOMDocumentFragmentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDocumentFragmentClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDocumentTypeClass {
    pub parent_class: WebKitDOMNodeClass,
}

impl ::std::fmt::Debug for WebKitDOMDocumentTypeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDocumentTypeClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMElementClass {
    pub parent_class: WebKitDOMNodeClass,
}

impl ::std::fmt::Debug for WebKitDOMElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMEntityReferenceClass {
    pub parent_class: WebKitDOMNodeClass,
}

impl ::std::fmt::Debug for WebKitDOMEntityReferenceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMEntityReferenceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMEventClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMEventClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMEventClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMEventTargetIface {
    pub gIface: gobject::GTypeInterface,
    pub dispatch_event: Option<
        unsafe extern "C" fn(
            *mut WebKitDOMEventTarget,
            *mut WebKitDOMEvent,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub add_event_listener: Option<
        unsafe extern "C" fn(
            *mut WebKitDOMEventTarget,
            *const c_char,
            *mut gobject::GClosure,
            gboolean,
        ) -> gboolean,
    >,
    pub remove_event_listener: Option<
        unsafe extern "C" fn(
            *mut WebKitDOMEventTarget,
            *const c_char,
            *mut gobject::GClosure,
            gboolean,
        ) -> gboolean,
    >,
    pub _webkitdom_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitDOMEventTargetIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMEventTargetIface @ {self:p}"))
            .field("gIface", &self.gIface)
            .field("dispatch_event", &self.dispatch_event)
            .field("add_event_listener", &self.add_event_listener)
            .field("remove_event_listener", &self.remove_event_listener)
            .field("_webkitdom_reserved0", &self._webkitdom_reserved0)
            .field("_webkitdom_reserved1", &self._webkitdom_reserved1)
            .field("_webkitdom_reserved2", &self._webkitdom_reserved2)
            .field("_webkitdom_reserved3", &self._webkitdom_reserved3)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMFileClass {
    pub parent_class: WebKitDOMBlobClass,
}

impl ::std::fmt::Debug for WebKitDOMFileClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMFileClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMFileListClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMFileListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMFileListClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLAnchorElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLAnchorElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLAnchorElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLAppletElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLAppletElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLAppletElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLAreaElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLAreaElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLAreaElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBRElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBRElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBRElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBaseElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBaseElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBaseElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBaseFontElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBaseFontElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBaseFontElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBodyElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBodyElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBodyElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLButtonElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLButtonElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLButtonElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLCanvasElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLCanvasElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLCanvasElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLCollectionClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLCollectionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLCollectionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDListElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDListElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDListElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDirectoryElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDirectoryElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDirectoryElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDivElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDivElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDivElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDocumentClass {
    pub parent_class: WebKitDOMDocumentClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDocumentClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDocumentClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLElementClass {
    pub parent_class: WebKitDOMElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLEmbedElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLEmbedElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLEmbedElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFieldSetElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFieldSetElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFieldSetElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFontElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFontElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFontElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFormElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFormElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFormElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFrameElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFrameElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFrameElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFrameSetElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFrameSetElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFrameSetElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHRElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHRElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHRElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHeadElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHeadElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHeadElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHeadingElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHeadingElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHeadingElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHtmlElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHtmlElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHtmlElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLIFrameElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLIFrameElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLIFrameElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLImageElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLImageElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLImageElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLInputElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLInputElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLInputElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLIElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLIElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLIElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLabelElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLabelElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLabelElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLegendElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLegendElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLegendElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLinkElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLinkElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLinkElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMapElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMapElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMapElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMarqueeElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMarqueeElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMarqueeElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMenuElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMenuElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMenuElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMetaElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMetaElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMetaElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLModElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLModElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLModElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOListElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOListElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOListElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLObjectElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLObjectElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLObjectElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOptGroupElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOptGroupElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOptGroupElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOptionElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOptionElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOptionElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOptionsCollectionClass {
    pub parent_class: WebKitDOMHTMLCollectionClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOptionsCollectionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOptionsCollectionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLParagraphElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLParagraphElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLParagraphElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLParamElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLParamElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLParamElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLPreElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLPreElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLPreElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLQuoteElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLQuoteElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLQuoteElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLScriptElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLScriptElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLScriptElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLSelectElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLSelectElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLSelectElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLStyleElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLStyleElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLStyleElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableCaptionElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableCaptionElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableCaptionElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableCellElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableCellElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableCellElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableColElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableColElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableColElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableRowElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableRowElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableRowElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableSectionElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableSectionElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableSectionElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTextAreaElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTextAreaElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTextAreaElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTitleElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTitleElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTitleElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLUListElementClass {
    pub parent_class: WebKitDOMHTMLElementClass,
}

impl ::std::fmt::Debug for WebKitDOMHTMLUListElementClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLUListElementClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMKeyboardEventClass {
    pub parent_class: WebKitDOMUIEventClass,
}

impl ::std::fmt::Debug for WebKitDOMKeyboardEventClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMKeyboardEventClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMMediaListClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMMediaListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMMediaListClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMMouseEventClass {
    pub parent_class: WebKitDOMUIEventClass,
}

impl ::std::fmt::Debug for WebKitDOMMouseEventClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMMouseEventClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNamedNodeMapClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMNamedNodeMapClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNamedNodeMapClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNodeClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMNodeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNodeClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNodeFilterIface {
    pub gIface: gobject::GTypeInterface,
    pub accept_node:
        Option<unsafe extern "C" fn(*mut WebKitDOMNodeFilter, *mut WebKitDOMNode) -> c_short>,
    pub _webkitdom_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitDOMNodeFilterIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNodeFilterIface @ {self:p}"))
            .field("gIface", &self.gIface)
            .field("accept_node", &self.accept_node)
            .field("_webkitdom_reserved0", &self._webkitdom_reserved0)
            .field("_webkitdom_reserved1", &self._webkitdom_reserved1)
            .field("_webkitdom_reserved2", &self._webkitdom_reserved2)
            .field("_webkitdom_reserved3", &self._webkitdom_reserved3)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNodeIteratorClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMNodeIteratorClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNodeIteratorClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNodeListClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMNodeListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNodeListClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMObjectClass {
    pub parentClass: gobject::GObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMObjectClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMObjectClass @ {self:p}"))
            .field("parentClass", &self.parentClass)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMProcessingInstructionClass {
    pub parent_class: WebKitDOMCharacterDataClass,
}

impl ::std::fmt::Debug for WebKitDOMProcessingInstructionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMProcessingInstructionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMRangeClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMRangeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMRangeClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMStyleSheetClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMStyleSheetClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMStyleSheetClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMStyleSheetListClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMStyleSheetListClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMStyleSheetListClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMTextClass {
    pub parent_class: WebKitDOMCharacterDataClass,
}

impl ::std::fmt::Debug for WebKitDOMTextClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMTextClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMTreeWalkerClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMTreeWalkerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMTreeWalkerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMUIEventClass {
    pub parent_class: WebKitDOMEventClass,
}

impl ::std::fmt::Debug for WebKitDOMUIEventClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMUIEventClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMWheelEventClass {
    pub parent_class: WebKitDOMMouseEventClass,
}

impl ::std::fmt::Debug for WebKitDOMWheelEventClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMWheelEventClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMXPathExpressionClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMXPathExpressionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMXPathExpressionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMXPathNSResolverIface {
    pub gIface: gobject::GTypeInterface,
    pub lookup_namespace_uri:
        Option<unsafe extern "C" fn(*mut WebKitDOMXPathNSResolver, *const c_char) -> *mut c_char>,
    pub _webkitdom_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkitdom_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitDOMXPathNSResolverIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMXPathNSResolverIface @ {self:p}"))
            .field("gIface", &self.gIface)
            .field("lookup_namespace_uri", &self.lookup_namespace_uri)
            .field("_webkitdom_reserved0", &self._webkitdom_reserved0)
            .field("_webkitdom_reserved1", &self._webkitdom_reserved1)
            .field("_webkitdom_reserved2", &self._webkitdom_reserved2)
            .field("_webkitdom_reserved3", &self._webkitdom_reserved3)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMXPathResultClass {
    pub parent_class: WebKitDOMObjectClass,
}

impl ::std::fmt::Debug for WebKitDOMXPathResultClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMXPathResultClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitFrameClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for WebKitFrameClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitFrameClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitFramePrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitFramePrivate = *mut _WebKitFramePrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitHitTestResultClass {
    pub parent_class: gobject::GObjectClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitHitTestResultClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitHitTestResultClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitHitTestResultPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitHitTestResultPrivate = *mut _WebKitHitTestResultPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitScriptWorldClass {
    pub parent_class: gobject::GObjectClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitScriptWorldClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitScriptWorldClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitScriptWorldPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitScriptWorldPrivate = *mut _WebKitScriptWorldPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitURIRequestClass {
    pub parent_class: gobject::GObjectClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitURIRequestClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitURIRequestClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitURIRequestPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitURIRequestPrivate = *mut _WebKitURIRequestPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitURIResponseClass {
    pub parent_class: gobject::GObjectClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitURIResponseClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitURIResponseClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitURIResponsePrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitURIResponsePrivate = *mut _WebKitURIResponsePrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitUserMessageClass {
    pub parent_class: gobject::GInitiallyUnownedClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitUserMessageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitUserMessageClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitUserMessagePrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitUserMessagePrivate = *mut _WebKitUserMessagePrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebEditorClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for WebKitWebEditorClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebEditorClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitWebEditorPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitWebEditorPrivate = *mut _WebKitWebEditorPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebExtensionClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for WebKitWebExtensionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebExtensionClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitWebExtensionPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitWebExtensionPrivate = *mut _WebKitWebExtensionPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebHitTestResultClass {
    pub parent_class: WebKitHitTestResultClass,
    pub _webkit_reserved0: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved1: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved2: Option<unsafe extern "C" fn()>,
    pub _webkit_reserved3: Option<unsafe extern "C" fn()>,
}

impl ::std::fmt::Debug for WebKitWebHitTestResultClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebHitTestResultClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("_webkit_reserved0", &self._webkit_reserved0)
            .field("_webkit_reserved1", &self._webkit_reserved1)
            .field("_webkit_reserved2", &self._webkit_reserved2)
            .field("_webkit_reserved3", &self._webkit_reserved3)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitWebHitTestResultPrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitWebHitTestResultPrivate = *mut _WebKitWebHitTestResultPrivate;

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebPageClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for WebKitWebPageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebPageClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[repr(C)]
pub struct _WebKitWebPagePrivate {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

pub type WebKitWebPagePrivate = *mut _WebKitWebPagePrivate;

// Classes
#[repr(C)]
pub struct WebKitContextMenu {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for WebKitContextMenu {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitContextMenu @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
pub struct WebKitContextMenuItem {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for WebKitContextMenuItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitContextMenuItem @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMAttr {
    pub parent_instance: WebKitDOMNode,
}

impl ::std::fmt::Debug for WebKitDOMAttr {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMAttr @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMBlob {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMBlob {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMBlob @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCDATASection {
    pub parent_instance: WebKitDOMText,
}

impl ::std::fmt::Debug for WebKitDOMCDATASection {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCDATASection @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSRule {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMCSSRule {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSRule @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSRuleList {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMCSSRuleList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSRuleList @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSStyleDeclaration {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMCSSStyleDeclaration {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSStyleDeclaration @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSStyleSheet {
    pub parent_instance: WebKitDOMStyleSheet,
}

impl ::std::fmt::Debug for WebKitDOMCSSStyleSheet {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSStyleSheet @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCSSValue {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMCSSValue {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCSSValue @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMCharacterData {
    pub parent_instance: WebKitDOMNode,
}

impl ::std::fmt::Debug for WebKitDOMCharacterData {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMCharacterData @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMClientRect {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMClientRect {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMClientRect @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMClientRectList {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMClientRectList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMClientRectList @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMComment {
    pub parent_instance: WebKitDOMCharacterData,
}

impl ::std::fmt::Debug for WebKitDOMComment {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMComment @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMImplementation {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMDOMImplementation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMImplementation @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMSelection {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMDOMSelection {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMSelection @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMTokenList {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMDOMTokenList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMTokenList @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDOMWindow {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMDOMWindow {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDOMWindow @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDocument {
    pub parent_instance: WebKitDOMNode,
}

impl ::std::fmt::Debug for WebKitDOMDocument {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDocument @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDocumentFragment {
    pub parent_instance: WebKitDOMNode,
}

impl ::std::fmt::Debug for WebKitDOMDocumentFragment {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDocumentFragment @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMDocumentType {
    pub parent_instance: WebKitDOMNode,
}

impl ::std::fmt::Debug for WebKitDOMDocumentType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMDocumentType @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMElement {
    pub parent_instance: WebKitDOMNode,
}

impl ::std::fmt::Debug for WebKitDOMElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMEntityReference {
    pub parent_instance: WebKitDOMNode,
}

impl ::std::fmt::Debug for WebKitDOMEntityReference {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMEntityReference @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMEvent {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMEvent @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMFile {
    pub parent_instance: WebKitDOMBlob,
}

impl ::std::fmt::Debug for WebKitDOMFile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMFile @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMFileList {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMFileList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMFileList @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLAnchorElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLAnchorElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLAnchorElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLAppletElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLAppletElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLAppletElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLAreaElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLAreaElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLAreaElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBRElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBRElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBRElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBaseElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBaseElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBaseElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBaseFontElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBaseFontElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBaseFontElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLBodyElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLBodyElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLBodyElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLButtonElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLButtonElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLButtonElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLCanvasElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLCanvasElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLCanvasElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLCollection {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMHTMLCollection {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLCollection @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDListElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDListElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDListElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDirectoryElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDirectoryElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDirectoryElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDivElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDivElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDivElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLDocument {
    pub parent_instance: WebKitDOMDocument,
}

impl ::std::fmt::Debug for WebKitDOMHTMLDocument {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLDocument @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLElement {
    pub parent_instance: WebKitDOMElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLEmbedElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLEmbedElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLEmbedElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFieldSetElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFieldSetElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFieldSetElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFontElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFontElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFontElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFormElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFormElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFormElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFrameElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFrameElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFrameElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLFrameSetElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLFrameSetElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLFrameSetElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHRElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHRElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHRElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHeadElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHeadElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHeadElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHeadingElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHeadingElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHeadingElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLHtmlElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLHtmlElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLHtmlElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLIFrameElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLIFrameElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLIFrameElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLImageElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLImageElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLImageElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLInputElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLInputElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLInputElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLIElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLIElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLIElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLabelElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLabelElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLabelElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLegendElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLegendElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLegendElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLLinkElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLLinkElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLLinkElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMapElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMapElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMapElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMarqueeElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMarqueeElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMarqueeElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMenuElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMenuElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMenuElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLMetaElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLMetaElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLMetaElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLModElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLModElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLModElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOListElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOListElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOListElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLObjectElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLObjectElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLObjectElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOptGroupElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOptGroupElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOptGroupElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOptionElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOptionElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOptionElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLOptionsCollection {
    pub parent_instance: WebKitDOMHTMLCollection,
}

impl ::std::fmt::Debug for WebKitDOMHTMLOptionsCollection {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLOptionsCollection @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLParagraphElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLParagraphElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLParagraphElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLParamElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLParamElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLParamElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLPreElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLPreElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLPreElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLQuoteElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLQuoteElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLQuoteElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLScriptElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLScriptElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLScriptElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLSelectElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLSelectElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLSelectElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLStyleElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLStyleElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLStyleElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableCaptionElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableCaptionElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableCaptionElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableCellElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableCellElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableCellElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableColElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableColElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableColElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableRowElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableRowElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableRowElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTableSectionElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTableSectionElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTableSectionElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTextAreaElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTextAreaElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTextAreaElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLTitleElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLTitleElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLTitleElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMHTMLUListElement {
    pub parent_instance: WebKitDOMHTMLElement,
}

impl ::std::fmt::Debug for WebKitDOMHTMLUListElement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMHTMLUListElement @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMKeyboardEvent {
    pub parent_instance: WebKitDOMUIEvent,
}

impl ::std::fmt::Debug for WebKitDOMKeyboardEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMKeyboardEvent @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMMediaList {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMMediaList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMMediaList @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMMouseEvent {
    pub parent_instance: WebKitDOMUIEvent,
}

impl ::std::fmt::Debug for WebKitDOMMouseEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMMouseEvent @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNamedNodeMap {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMNamedNodeMap {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNamedNodeMap @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNode {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNode @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNodeIterator {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMNodeIterator {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNodeIterator @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMNodeList {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMNodeList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMNodeList @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMObject {
    pub parentInstance: gobject::GObject,
    pub coreObject: gpointer,
}

impl ::std::fmt::Debug for WebKitDOMObject {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMObject @ {self:p}"))
            .field("parentInstance", &self.parentInstance)
            .field("coreObject", &self.coreObject)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMProcessingInstruction {
    pub parent_instance: WebKitDOMCharacterData,
}

impl ::std::fmt::Debug for WebKitDOMProcessingInstruction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMProcessingInstruction @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMRange {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMRange {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMRange @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMStyleSheet {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMStyleSheet {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMStyleSheet @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMStyleSheetList {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMStyleSheetList {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMStyleSheetList @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMText {
    pub parent_instance: WebKitDOMCharacterData,
}

impl ::std::fmt::Debug for WebKitDOMText {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMText @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMTreeWalker {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMTreeWalker {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMTreeWalker @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMUIEvent {
    pub parent_instance: WebKitDOMEvent,
}

impl ::std::fmt::Debug for WebKitDOMUIEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMUIEvent @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMWheelEvent {
    pub parent_instance: WebKitDOMMouseEvent,
}

impl ::std::fmt::Debug for WebKitDOMWheelEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMWheelEvent @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMXPathExpression {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMXPathExpression {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMXPathExpression @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitDOMXPathResult {
    pub parent_instance: WebKitDOMObject,
}

impl ::std::fmt::Debug for WebKitDOMXPathResult {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitDOMXPathResult @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitFrame {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitFramePrivate,
}

impl ::std::fmt::Debug for WebKitFrame {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitFrame @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitHitTestResult {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitHitTestResultPrivate,
}

impl ::std::fmt::Debug for WebKitHitTestResult {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitHitTestResult @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitScriptWorld {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitScriptWorldPrivate,
}

impl ::std::fmt::Debug for WebKitScriptWorld {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitScriptWorld @ {self:p}"))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitURIRequest {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitURIRequestPrivate,
}

impl ::std::fmt::Debug for WebKitURIRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitURIRequest @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitURIResponse {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitURIResponsePrivate,
}

impl ::std::fmt::Debug for WebKitURIResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitURIResponse @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitUserMessage {
    pub parent: gobject::GInitiallyUnowned,
    pub priv_: *mut WebKitUserMessagePrivate,
}

impl ::std::fmt::Debug for WebKitUserMessage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitUserMessage @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebEditor {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitWebEditorPrivate,
}

impl ::std::fmt::Debug for WebKitWebEditor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebEditor @ {self:p}"))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebExtension {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitWebExtensionPrivate,
}

impl ::std::fmt::Debug for WebKitWebExtension {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebExtension @ {self:p}"))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebHitTestResult {
    pub parent: WebKitHitTestResult,
    pub priv_: *mut WebKitWebHitTestResultPrivate,
}

impl ::std::fmt::Debug for WebKitWebHitTestResult {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebHitTestResult @ {self:p}"))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct WebKitWebPage {
    pub parent: gobject::GObject,
    pub priv_: *mut WebKitWebPagePrivate,
}

impl ::std::fmt::Debug for WebKitWebPage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("WebKitWebPage @ {self:p}"))
            .field("parent", &self.parent)
            .finish()
    }
}

// Interfaces
#[repr(C)]
pub struct WebKitDOMEventTarget {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for WebKitDOMEventTarget {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "WebKitDOMEventTarget @ {self:p}")
    }
}

#[repr(C)]
pub struct WebKitDOMNodeFilter {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for WebKitDOMNodeFilter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "WebKitDOMNodeFilter @ {self:p}")
    }
}

#[repr(C)]
pub struct WebKitDOMXPathNSResolver {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for WebKitDOMXPathNSResolver {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "WebKitDOMXPathNSResolver @ {self:p}")
    }
}

#[link(name = "webkit2gtk-5.0")]
extern "C" {

    //=========================================================================
    // WebKitConsoleMessageLevel
    //=========================================================================
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_level_get_type() -> GType;

    //=========================================================================
    // WebKitConsoleMessageSource
    //=========================================================================
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_source_get_type() -> GType;

    //=========================================================================
    // WebKitFormSubmissionStep
    //=========================================================================
    #[cfg(any(feature = "v2_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_20")))]
    pub fn webkit_form_submission_step_get_type() -> GType;

    //=========================================================================
    // WebKitConsoleMessage
    //=========================================================================
    pub fn webkit_console_message_get_type() -> GType;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_copy(
        console_message: *mut WebKitConsoleMessage,
    ) -> *mut WebKitConsoleMessage;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_free(console_message: *mut WebKitConsoleMessage);
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_get_level(
        console_message: *mut WebKitConsoleMessage,
    ) -> WebKitConsoleMessageLevel;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_get_line(console_message: *mut WebKitConsoleMessage) -> c_uint;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_get_source(
        console_message: *mut WebKitConsoleMessage,
    ) -> WebKitConsoleMessageSource;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_get_source_id(
        console_message: *mut WebKitConsoleMessage,
    ) -> *const c_char;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_console_message_get_text(
        console_message: *mut WebKitConsoleMessage,
    ) -> *const c_char;

    //=========================================================================
    // WebKitContextMenu
    //=========================================================================
    pub fn webkit_context_menu_get_type() -> GType;
    pub fn webkit_context_menu_new() -> *mut WebKitContextMenu;
    pub fn webkit_context_menu_new_with_items(items: *mut glib::GList) -> *mut WebKitContextMenu;
    pub fn webkit_context_menu_append(
        menu: *mut WebKitContextMenu,
        item: *mut WebKitContextMenuItem,
    );
    pub fn webkit_context_menu_first(menu: *mut WebKitContextMenu) -> *mut WebKitContextMenuItem;
    pub fn webkit_context_menu_get_item_at_position(
        menu: *mut WebKitContextMenu,
        position: c_uint,
    ) -> *mut WebKitContextMenuItem;
    pub fn webkit_context_menu_get_items(menu: *mut WebKitContextMenu) -> *mut glib::GList;
    pub fn webkit_context_menu_get_n_items(menu: *mut WebKitContextMenu) -> c_uint;
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_context_menu_get_user_data(menu: *mut WebKitContextMenu) -> *mut glib::GVariant;
    pub fn webkit_context_menu_insert(
        menu: *mut WebKitContextMenu,
        item: *mut WebKitContextMenuItem,
        position: c_int,
    );
    pub fn webkit_context_menu_last(menu: *mut WebKitContextMenu) -> *mut WebKitContextMenuItem;
    pub fn webkit_context_menu_move_item(
        menu: *mut WebKitContextMenu,
        item: *mut WebKitContextMenuItem,
        position: c_int,
    );
    pub fn webkit_context_menu_prepend(
        menu: *mut WebKitContextMenu,
        item: *mut WebKitContextMenuItem,
    );
    pub fn webkit_context_menu_remove(
        menu: *mut WebKitContextMenu,
        item: *mut WebKitContextMenuItem,
    );
    pub fn webkit_context_menu_remove_all(menu: *mut WebKitContextMenu);
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_context_menu_set_user_data(
        menu: *mut WebKitContextMenu,
        user_data: *mut glib::GVariant,
    );

    //=========================================================================
    // WebKitContextMenuItem
    //=========================================================================
    pub fn webkit_context_menu_item_get_type() -> GType;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_context_menu_item_new_from_gaction(
        action: *mut gio::GAction,
        label: *const c_char,
        target: *mut glib::GVariant,
    ) -> *mut WebKitContextMenuItem;
    pub fn webkit_context_menu_item_new_from_stock_action(
        action: WebKitContextMenuAction,
    ) -> *mut WebKitContextMenuItem;
    pub fn webkit_context_menu_item_new_from_stock_action_with_label(
        action: WebKitContextMenuAction,
        label: *const c_char,
    ) -> *mut WebKitContextMenuItem;
    pub fn webkit_context_menu_item_new_separator() -> *mut WebKitContextMenuItem;
    pub fn webkit_context_menu_item_new_with_submenu(
        label: *const c_char,
        submenu: *mut WebKitContextMenu,
    ) -> *mut WebKitContextMenuItem;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_context_menu_item_get_gaction(
        item: *mut WebKitContextMenuItem,
    ) -> *mut gio::GAction;
    pub fn webkit_context_menu_item_get_stock_action(
        item: *mut WebKitContextMenuItem,
    ) -> WebKitContextMenuAction;
    pub fn webkit_context_menu_item_get_submenu(
        item: *mut WebKitContextMenuItem,
    ) -> *mut WebKitContextMenu;
    pub fn webkit_context_menu_item_is_separator(item: *mut WebKitContextMenuItem) -> gboolean;
    pub fn webkit_context_menu_item_set_submenu(
        item: *mut WebKitContextMenuItem,
        submenu: *mut WebKitContextMenu,
    );

    //=========================================================================
    // WebKitDOMAttr
    //=========================================================================
    pub fn webkit_dom_attr_get_type() -> GType;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_attr_get_local_name(self_: *mut WebKitDOMAttr) -> *mut c_char;
    pub fn webkit_dom_attr_get_name(self_: *mut WebKitDOMAttr) -> *mut c_char;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_attr_get_namespace_uri(self_: *mut WebKitDOMAttr) -> *mut c_char;
    pub fn webkit_dom_attr_get_owner_element(self_: *mut WebKitDOMAttr) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_attr_get_prefix(self_: *mut WebKitDOMAttr) -> *mut c_char;
    pub fn webkit_dom_attr_get_specified(self_: *mut WebKitDOMAttr) -> gboolean;
    pub fn webkit_dom_attr_get_value(self_: *mut WebKitDOMAttr) -> *mut c_char;
    pub fn webkit_dom_attr_set_value(
        self_: *mut WebKitDOMAttr,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMBlob
    //=========================================================================
    pub fn webkit_dom_blob_get_type() -> GType;
    pub fn webkit_dom_blob_get_size(self_: *mut WebKitDOMBlob) -> u64;

    //=========================================================================
    // WebKitDOMCDATASection
    //=========================================================================
    pub fn webkit_dom_cdata_section_get_type() -> GType;

    //=========================================================================
    // WebKitDOMCSSRule
    //=========================================================================
    pub fn webkit_dom_css_rule_get_type() -> GType;
    pub fn webkit_dom_css_rule_get_css_text(self_: *mut WebKitDOMCSSRule) -> *mut c_char;
    pub fn webkit_dom_css_rule_get_parent_rule(
        self_: *mut WebKitDOMCSSRule,
    ) -> *mut WebKitDOMCSSRule;
    pub fn webkit_dom_css_rule_get_parent_style_sheet(
        self_: *mut WebKitDOMCSSRule,
    ) -> *mut WebKitDOMCSSStyleSheet;
    pub fn webkit_dom_css_rule_get_rule_type(self_: *mut WebKitDOMCSSRule) -> c_ushort;
    pub fn webkit_dom_css_rule_set_css_text(
        self_: *mut WebKitDOMCSSRule,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMCSSRuleList
    //=========================================================================
    pub fn webkit_dom_css_rule_list_get_type() -> GType;
    pub fn webkit_dom_css_rule_list_get_length(self_: *mut WebKitDOMCSSRuleList) -> c_ulong;
    pub fn webkit_dom_css_rule_list_item(
        self_: *mut WebKitDOMCSSRuleList,
        index: c_ulong,
    ) -> *mut WebKitDOMCSSRule;

    //=========================================================================
    // WebKitDOMCSSStyleDeclaration
    //=========================================================================
    pub fn webkit_dom_css_style_declaration_get_type() -> GType;
    pub fn webkit_dom_css_style_declaration_get_css_text(
        self_: *mut WebKitDOMCSSStyleDeclaration,
    ) -> *mut c_char;
    pub fn webkit_dom_css_style_declaration_get_length(
        self_: *mut WebKitDOMCSSStyleDeclaration,
    ) -> c_ulong;
    pub fn webkit_dom_css_style_declaration_get_parent_rule(
        self_: *mut WebKitDOMCSSStyleDeclaration,
    ) -> *mut WebKitDOMCSSRule;
    pub fn webkit_dom_css_style_declaration_get_property_priority(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        propertyName: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_css_style_declaration_get_property_shorthand(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        propertyName: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_css_style_declaration_get_property_value(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        propertyName: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_css_style_declaration_is_property_implicit(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        propertyName: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_css_style_declaration_item(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        index: c_ulong,
    ) -> *mut c_char;
    pub fn webkit_dom_css_style_declaration_remove_property(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        propertyName: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn webkit_dom_css_style_declaration_set_css_text(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_css_style_declaration_set_property(
        self_: *mut WebKitDOMCSSStyleDeclaration,
        propertyName: *const c_char,
        value: *const c_char,
        priority: *const c_char,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMCSSStyleSheet
    //=========================================================================
    pub fn webkit_dom_css_style_sheet_get_type() -> GType;
    pub fn webkit_dom_css_style_sheet_add_rule(
        self_: *mut WebKitDOMCSSStyleSheet,
        selector: *const c_char,
        style: *const c_char,
        index: c_ulong,
        error: *mut *mut glib::GError,
    ) -> c_long;
    pub fn webkit_dom_css_style_sheet_delete_rule(
        self_: *mut WebKitDOMCSSStyleSheet,
        index: c_ulong,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_css_style_sheet_get_css_rules(
        self_: *mut WebKitDOMCSSStyleSheet,
    ) -> *mut WebKitDOMCSSRuleList;
    pub fn webkit_dom_css_style_sheet_get_owner_rule(
        self_: *mut WebKitDOMCSSStyleSheet,
    ) -> *mut WebKitDOMCSSRule;
    pub fn webkit_dom_css_style_sheet_get_rules(
        self_: *mut WebKitDOMCSSStyleSheet,
    ) -> *mut WebKitDOMCSSRuleList;
    pub fn webkit_dom_css_style_sheet_insert_rule(
        self_: *mut WebKitDOMCSSStyleSheet,
        rule: *const c_char,
        index: c_ulong,
        error: *mut *mut glib::GError,
    ) -> c_ulong;
    pub fn webkit_dom_css_style_sheet_remove_rule(
        self_: *mut WebKitDOMCSSStyleSheet,
        index: c_ulong,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMCSSValue
    //=========================================================================
    pub fn webkit_dom_css_value_get_type() -> GType;
    pub fn webkit_dom_css_value_get_css_text(self_: *mut WebKitDOMCSSValue) -> *mut c_char;
    pub fn webkit_dom_css_value_get_css_value_type(self_: *mut WebKitDOMCSSValue) -> c_ushort;
    pub fn webkit_dom_css_value_set_css_text(
        self_: *mut WebKitDOMCSSValue,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMCharacterData
    //=========================================================================
    pub fn webkit_dom_character_data_get_type() -> GType;
    pub fn webkit_dom_character_data_append_data(
        self_: *mut WebKitDOMCharacterData,
        data: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_character_data_delete_data(
        self_: *mut WebKitDOMCharacterData,
        offset: c_ulong,
        length: c_ulong,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_character_data_get_data(self_: *mut WebKitDOMCharacterData) -> *mut c_char;
    pub fn webkit_dom_character_data_get_length(self_: *mut WebKitDOMCharacterData) -> c_ulong;
    pub fn webkit_dom_character_data_insert_data(
        self_: *mut WebKitDOMCharacterData,
        offset: c_ulong,
        data: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_character_data_replace_data(
        self_: *mut WebKitDOMCharacterData,
        offset: c_ulong,
        length: c_ulong,
        data: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_character_data_set_data(
        self_: *mut WebKitDOMCharacterData,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_character_data_substring_data(
        self_: *mut WebKitDOMCharacterData,
        offset: c_ulong,
        length: c_ulong,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;

    //=========================================================================
    // WebKitDOMClientRect
    //=========================================================================
    pub fn webkit_dom_client_rect_get_type() -> GType;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_get_bottom(self_: *mut WebKitDOMClientRect) -> c_float;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_get_height(self_: *mut WebKitDOMClientRect) -> c_float;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_get_left(self_: *mut WebKitDOMClientRect) -> c_float;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_get_right(self_: *mut WebKitDOMClientRect) -> c_float;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_get_top(self_: *mut WebKitDOMClientRect) -> c_float;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_get_width(self_: *mut WebKitDOMClientRect) -> c_float;

    //=========================================================================
    // WebKitDOMClientRectList
    //=========================================================================
    pub fn webkit_dom_client_rect_list_get_type() -> GType;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_list_get_length(self_: *mut WebKitDOMClientRectList) -> c_ulong;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_client_rect_list_item(
        self_: *mut WebKitDOMClientRectList,
        index: c_ulong,
    ) -> *mut WebKitDOMClientRect;

    //=========================================================================
    // WebKitDOMComment
    //=========================================================================
    pub fn webkit_dom_comment_get_type() -> GType;

    //=========================================================================
    // WebKitDOMDOMImplementation
    //=========================================================================
    pub fn webkit_dom_dom_implementation_get_type() -> GType;
    pub fn webkit_dom_dom_implementation_create_css_style_sheet(
        self_: *mut WebKitDOMDOMImplementation,
        title: *const c_char,
        media: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMCSSStyleSheet;
    pub fn webkit_dom_dom_implementation_create_document(
        self_: *mut WebKitDOMDOMImplementation,
        namespaceURI: *const c_char,
        qualifiedName: *const c_char,
        doctype: *mut WebKitDOMDocumentType,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMDocument;
    pub fn webkit_dom_dom_implementation_create_document_type(
        self_: *mut WebKitDOMDOMImplementation,
        qualifiedName: *const c_char,
        publicId: *const c_char,
        systemId: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMDocumentType;
    pub fn webkit_dom_dom_implementation_create_html_document(
        self_: *mut WebKitDOMDOMImplementation,
        title: *const c_char,
    ) -> *mut WebKitDOMHTMLDocument;
    pub fn webkit_dom_dom_implementation_has_feature(
        self_: *mut WebKitDOMDOMImplementation,
        feature: *const c_char,
        version: *const c_char,
    ) -> gboolean;

    //=========================================================================
    // WebKitDOMDOMSelection
    //=========================================================================
    pub fn webkit_dom_dom_selection_get_type() -> GType;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_add_range(
        self_: *mut WebKitDOMDOMSelection,
        range: *mut WebKitDOMRange,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_collapse(
        self_: *mut WebKitDOMDOMSelection,
        node: *mut WebKitDOMNode,
        offset: c_ulong,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_collapse_to_end(
        self_: *mut WebKitDOMDOMSelection,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_collapse_to_start(
        self_: *mut WebKitDOMDOMSelection,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_contains_node(
        self_: *mut WebKitDOMDOMSelection,
        node: *mut WebKitDOMNode,
        allowPartial: gboolean,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_delete_from_document(self_: *mut WebKitDOMDOMSelection);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_empty(self_: *mut WebKitDOMDOMSelection);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_extend(
        self_: *mut WebKitDOMDOMSelection,
        node: *mut WebKitDOMNode,
        offset: c_ulong,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_anchor_node(
        self_: *mut WebKitDOMDOMSelection,
    ) -> *mut WebKitDOMNode;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_anchor_offset(self_: *mut WebKitDOMDOMSelection)
        -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_base_node(
        self_: *mut WebKitDOMDOMSelection,
    ) -> *mut WebKitDOMNode;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_base_offset(self_: *mut WebKitDOMDOMSelection) -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_extent_node(
        self_: *mut WebKitDOMDOMSelection,
    ) -> *mut WebKitDOMNode;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_extent_offset(self_: *mut WebKitDOMDOMSelection)
        -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_focus_node(
        self_: *mut WebKitDOMDOMSelection,
    ) -> *mut WebKitDOMNode;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_focus_offset(self_: *mut WebKitDOMDOMSelection) -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_is_collapsed(self_: *mut WebKitDOMDOMSelection)
        -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_range_at(
        self_: *mut WebKitDOMDOMSelection,
        index: c_ulong,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMRange;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_range_count(self_: *mut WebKitDOMDOMSelection) -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_get_selection_type(
        self_: *mut WebKitDOMDOMSelection,
    ) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_modify(
        self_: *mut WebKitDOMDOMSelection,
        alter: *const c_char,
        direction: *const c_char,
        granularity: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_remove_all_ranges(self_: *mut WebKitDOMDOMSelection);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_select_all_children(
        self_: *mut WebKitDOMDOMSelection,
        node: *mut WebKitDOMNode,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_set_base_and_extent(
        self_: *mut WebKitDOMDOMSelection,
        baseNode: *mut WebKitDOMNode,
        baseOffset: c_ulong,
        extentNode: *mut WebKitDOMNode,
        extentOffset: c_ulong,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_selection_set_position(
        self_: *mut WebKitDOMDOMSelection,
        node: *mut WebKitDOMNode,
        offset: c_ulong,
    );

    //=========================================================================
    // WebKitDOMDOMTokenList
    //=========================================================================
    pub fn webkit_dom_dom_token_list_get_type() -> GType;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_add(
        self_: *mut WebKitDOMDOMTokenList,
        error: *mut *mut glib::GError,
        ...
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_contains(
        self_: *mut WebKitDOMDOMTokenList,
        token: *const c_char,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_get_length(self_: *mut WebKitDOMDOMTokenList) -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_get_value(self_: *mut WebKitDOMDOMTokenList) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_item(
        self_: *mut WebKitDOMDOMTokenList,
        index: c_ulong,
    ) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_remove(
        self_: *mut WebKitDOMDOMTokenList,
        error: *mut *mut glib::GError,
        ...
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_replace(
        self_: *mut WebKitDOMDOMTokenList,
        token: *const c_char,
        newToken: *const c_char,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_set_value(
        self_: *mut WebKitDOMDOMTokenList,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_token_list_toggle(
        self_: *mut WebKitDOMDOMTokenList,
        token: *const c_char,
        force: gboolean,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // WebKitDOMDOMWindow
    //=========================================================================
    pub fn webkit_dom_dom_window_get_type() -> GType;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_alert(self_: *mut WebKitDOMDOMWindow, message: *const c_char);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_blur(self_: *mut WebKitDOMDOMWindow);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_capture_events(self_: *mut WebKitDOMDOMWindow);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_close(self_: *mut WebKitDOMDOMWindow);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_confirm(
        self_: *mut WebKitDOMDOMWindow,
        message: *const c_char,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_find(
        self_: *mut WebKitDOMDOMWindow,
        string: *const c_char,
        caseSensitive: gboolean,
        backwards: gboolean,
        wrap: gboolean,
        wholeWord: gboolean,
        searchInFrames: gboolean,
        showDialog: gboolean,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_focus(self_: *mut WebKitDOMDOMWindow);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_closed(self_: *mut WebKitDOMDOMWindow) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_computed_style(
        self_: *mut WebKitDOMDOMWindow,
        element: *mut WebKitDOMElement,
        pseudoElement: *const c_char,
    ) -> *mut WebKitDOMCSSStyleDeclaration;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_default_status(self_: *mut WebKitDOMDOMWindow) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_device_pixel_ratio(self_: *mut WebKitDOMDOMWindow)
        -> c_double;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_document(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMDocument;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_frame_element(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_frames(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMDOMWindow;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_inner_height(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_inner_width(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_length(self_: *mut WebKitDOMDOMWindow) -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_name(self_: *mut WebKitDOMDOMWindow) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_offscreen_buffering(
        self_: *mut WebKitDOMDOMWindow,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_opener(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMDOMWindow;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_orientation(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_outer_height(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_outer_width(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_page_x_offset(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_page_y_offset(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_parent(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMDOMWindow;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_screen_left(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_screen_top(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_screen_x(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_screen_y(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_scroll_x(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_scroll_y(self_: *mut WebKitDOMDOMWindow) -> c_long;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_selection(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMDOMSelection;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_self(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMDOMWindow;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_status(self_: *mut WebKitDOMDOMWindow) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_top(self_: *mut WebKitDOMDOMWindow)
        -> *mut WebKitDOMDOMWindow;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_get_window(
        self_: *mut WebKitDOMDOMWindow,
    ) -> *mut WebKitDOMDOMWindow;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_move_by(self_: *mut WebKitDOMDOMWindow, x: c_float, y: c_float);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_move_to(self_: *mut WebKitDOMDOMWindow, x: c_float, y: c_float);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_print(self_: *mut WebKitDOMDOMWindow);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_prompt(
        self_: *mut WebKitDOMDOMWindow,
        message: *const c_char,
        defaultValue: *const c_char,
    ) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_release_events(self_: *mut WebKitDOMDOMWindow);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_resize_by(self_: *mut WebKitDOMDOMWindow, x: c_float, y: c_float);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_resize_to(
        self_: *mut WebKitDOMDOMWindow,
        width: c_float,
        height: c_float,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_scroll_by(
        self_: *mut WebKitDOMDOMWindow,
        x: c_double,
        y: c_double,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_scroll_to(
        self_: *mut WebKitDOMDOMWindow,
        x: c_double,
        y: c_double,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_set_default_status(
        self_: *mut WebKitDOMDOMWindow,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_set_name(self_: *mut WebKitDOMDOMWindow, value: *const c_char);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_set_status(self_: *mut WebKitDOMDOMWindow, value: *const c_char);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_dom_window_stop(self_: *mut WebKitDOMDOMWindow);
    pub fn webkit_dom_dom_window_webkit_message_handlers_post_message(
        window: *mut WebKitDOMDOMWindow,
        handler: *const c_char,
        message: *const c_char,
    ) -> gboolean;

    //=========================================================================
    // WebKitDOMDocument
    //=========================================================================
    pub fn webkit_dom_document_get_type() -> GType;
    pub fn webkit_dom_document_adopt_node(
        self_: *mut WebKitDOMDocument,
        source: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_caret_range_from_point(
        self_: *mut WebKitDOMDocument,
        x: c_long,
        y: c_long,
    ) -> *mut WebKitDOMRange;
    pub fn webkit_dom_document_create_attribute(
        self_: *mut WebKitDOMDocument,
        name: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMAttr;
    pub fn webkit_dom_document_create_attribute_ns(
        self_: *mut WebKitDOMDocument,
        namespaceURI: *const c_char,
        qualifiedName: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMAttr;
    pub fn webkit_dom_document_create_cdata_section(
        self_: *mut WebKitDOMDocument,
        data: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMCDATASection;
    pub fn webkit_dom_document_create_comment(
        self_: *mut WebKitDOMDocument,
        data: *const c_char,
    ) -> *mut WebKitDOMComment;
    pub fn webkit_dom_document_create_css_style_declaration(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMCSSStyleDeclaration;
    pub fn webkit_dom_document_create_document_fragment(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMDocumentFragment;
    pub fn webkit_dom_document_create_element(
        self_: *mut WebKitDOMDocument,
        tagName: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_create_element_ns(
        self_: *mut WebKitDOMDocument,
        namespaceURI: *const c_char,
        qualifiedName: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_create_entity_reference(
        self_: *mut WebKitDOMDocument,
        name: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMEntityReference;
    pub fn webkit_dom_document_create_event(
        self_: *mut WebKitDOMDocument,
        eventType: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMEvent;
    pub fn webkit_dom_document_create_expression(
        self_: *mut WebKitDOMDocument,
        expression: *const c_char,
        resolver: *mut WebKitDOMXPathNSResolver,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMXPathExpression;
    pub fn webkit_dom_document_create_node_iterator(
        self_: *mut WebKitDOMDocument,
        root: *mut WebKitDOMNode,
        whatToShow: c_ulong,
        filter: *mut WebKitDOMNodeFilter,
        expandEntityReferences: gboolean,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNodeIterator;
    pub fn webkit_dom_document_create_ns_resolver(
        self_: *mut WebKitDOMDocument,
        nodeResolver: *mut WebKitDOMNode,
    ) -> *mut WebKitDOMXPathNSResolver;
    pub fn webkit_dom_document_create_processing_instruction(
        self_: *mut WebKitDOMDocument,
        target: *const c_char,
        data: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMProcessingInstruction;
    pub fn webkit_dom_document_create_range(self_: *mut WebKitDOMDocument) -> *mut WebKitDOMRange;
    pub fn webkit_dom_document_create_text_node(
        self_: *mut WebKitDOMDocument,
        data: *const c_char,
    ) -> *mut WebKitDOMText;
    pub fn webkit_dom_document_create_tree_walker(
        self_: *mut WebKitDOMDocument,
        root: *mut WebKitDOMNode,
        whatToShow: c_ulong,
        filter: *mut WebKitDOMNodeFilter,
        expandEntityReferences: gboolean,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMTreeWalker;
    pub fn webkit_dom_document_element_from_point(
        self_: *mut WebKitDOMDocument,
        x: c_long,
        y: c_long,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_evaluate(
        self_: *mut WebKitDOMDocument,
        expression: *const c_char,
        contextNode: *mut WebKitDOMNode,
        resolver: *mut WebKitDOMXPathNSResolver,
        type_: c_ushort,
        inResult: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMXPathResult;
    pub fn webkit_dom_document_exec_command(
        self_: *mut WebKitDOMDocument,
        command: *const c_char,
        userInterface: gboolean,
        value: *const c_char,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_exit_pointer_lock(self_: *mut WebKitDOMDocument);
    pub fn webkit_dom_document_get_active_element(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_get_anchors(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_document_get_applets(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_document_get_body(self_: *mut WebKitDOMDocument)
        -> *mut WebKitDOMHTMLElement;
    pub fn webkit_dom_document_get_character_set(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_charset(self_: *mut WebKitDOMDocument) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_child_element_count(self_: *mut WebKitDOMDocument) -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_children(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_document_get_compat_mode(self_: *mut WebKitDOMDocument) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_content_type(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_cookie(
        self_: *mut WebKitDOMDocument,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_current_script(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLScriptElement;
    pub fn webkit_dom_document_get_default_charset(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_default_view(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMDOMWindow;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_document_get_design_mode(self_: *mut WebKitDOMDocument) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_dir(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_doctype(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMDocumentType;
    pub fn webkit_dom_document_get_document_element(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_get_document_uri(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_domain(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_element_by_id(
        self_: *mut WebKitDOMDocument,
        elementId: *const c_char,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_get_elements_by_class_name(
        self_: *mut WebKitDOMDocument,
        class_name: *const c_char,
    ) -> *mut WebKitDOMNodeList;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_dom_document_get_elements_by_class_name_as_html_collection(
        self_: *mut WebKitDOMDocument,
        classNames: *const c_char,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_document_get_elements_by_name(
        self_: *mut WebKitDOMDocument,
        elementName: *const c_char,
    ) -> *mut WebKitDOMNodeList;
    pub fn webkit_dom_document_get_elements_by_tag_name(
        self_: *mut WebKitDOMDocument,
        tag_name: *const c_char,
    ) -> *mut WebKitDOMNodeList;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_dom_document_get_elements_by_tag_name_as_html_collection(
        self_: *mut WebKitDOMDocument,
        tagname: *const c_char,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_document_get_elements_by_tag_name_ns(
        self_: *mut WebKitDOMDocument,
        namespace_uri: *const c_char,
        tag_name: *const c_char,
    ) -> *mut WebKitDOMNodeList;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_dom_document_get_elements_by_tag_name_ns_as_html_collection(
        self_: *mut WebKitDOMDocument,
        namespaceURI: *const c_char,
        localName: *const c_char,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_document_get_embeds(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_first_element_child(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_get_forms(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_document_get_head(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLHeadElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_hidden(self_: *mut WebKitDOMDocument) -> gboolean;
    pub fn webkit_dom_document_get_images(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_document_get_implementation(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMDOMImplementation;
    pub fn webkit_dom_document_get_input_encoding(self_: *mut WebKitDOMDocument) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_last_element_child(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_get_last_modified(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_links(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_origin(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_override_style(
        self_: *mut WebKitDOMDocument,
        element: *mut WebKitDOMElement,
        pseudoElement: *const c_char,
    ) -> *mut WebKitDOMCSSStyleDeclaration;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_document_get_plugins(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_pointer_lock_element(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_get_preferred_stylesheet_set(
        self_: *mut WebKitDOMDocument,
    ) -> *mut c_char;
    pub fn webkit_dom_document_get_ready_state(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_referrer(self_: *mut WebKitDOMDocument) -> *mut c_char;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_document_get_scripts(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_scrolling_element(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_get_selected_stylesheet_set(
        self_: *mut WebKitDOMDocument,
    ) -> *mut c_char;
    pub fn webkit_dom_document_get_style_sheets(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMStyleSheetList;
    pub fn webkit_dom_document_get_title(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_url(self_: *mut WebKitDOMDocument) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_visibility_state(self_: *mut WebKitDOMDocument) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_webkit_current_fullscreen_element(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_webkit_fullscreen_element(
        self_: *mut WebKitDOMDocument,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_webkit_fullscreen_enabled(
        self_: *mut WebKitDOMDocument,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_webkit_fullscreen_keyboard_input_allowed(
        self_: *mut WebKitDOMDocument,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_get_webkit_is_fullscreen(self_: *mut WebKitDOMDocument) -> gboolean;
    pub fn webkit_dom_document_get_xml_encoding(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_get_xml_standalone(self_: *mut WebKitDOMDocument) -> gboolean;
    pub fn webkit_dom_document_get_xml_version(self_: *mut WebKitDOMDocument) -> *mut c_char;
    pub fn webkit_dom_document_has_focus(self_: *mut WebKitDOMDocument) -> gboolean;
    pub fn webkit_dom_document_import_node(
        self_: *mut WebKitDOMDocument,
        importedNode: *mut WebKitDOMNode,
        deep: gboolean,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_document_query_command_enabled(
        self_: *mut WebKitDOMDocument,
        command: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_document_query_command_indeterm(
        self_: *mut WebKitDOMDocument,
        command: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_document_query_command_state(
        self_: *mut WebKitDOMDocument,
        command: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_document_query_command_supported(
        self_: *mut WebKitDOMDocument,
        command: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_document_query_command_value(
        self_: *mut WebKitDOMDocument,
        command: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_document_query_selector(
        self_: *mut WebKitDOMDocument,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_document_query_selector_all(
        self_: *mut WebKitDOMDocument,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNodeList;
    pub fn webkit_dom_document_set_body(
        self_: *mut WebKitDOMDocument,
        value: *mut WebKitDOMHTMLElement,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_document_set_charset(self_: *mut WebKitDOMDocument, value: *const c_char);
    pub fn webkit_dom_document_set_cookie(
        self_: *mut WebKitDOMDocument,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_document_set_design_mode(self_: *mut WebKitDOMDocument, value: *const c_char);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_set_dir(self_: *mut WebKitDOMDocument, value: *const c_char);
    pub fn webkit_dom_document_set_document_uri(
        self_: *mut WebKitDOMDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_document_set_selected_stylesheet_set(
        self_: *mut WebKitDOMDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_document_set_title(self_: *mut WebKitDOMDocument, value: *const c_char);
    pub fn webkit_dom_document_set_xml_standalone(
        self_: *mut WebKitDOMDocument,
        value: gboolean,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_document_set_xml_version(
        self_: *mut WebKitDOMDocument,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_webkit_cancel_fullscreen(self_: *mut WebKitDOMDocument);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_webkit_exit_fullscreen(self_: *mut WebKitDOMDocument);

    //=========================================================================
    // WebKitDOMDocumentFragment
    //=========================================================================
    pub fn webkit_dom_document_fragment_get_type() -> GType;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_fragment_get_child_element_count(
        self_: *mut WebKitDOMDocumentFragment,
    ) -> c_ulong;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_fragment_get_children(
        self_: *mut WebKitDOMDocumentFragment,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_fragment_get_element_by_id(
        self_: *mut WebKitDOMDocumentFragment,
        elementId: *const c_char,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_fragment_get_first_element_child(
        self_: *mut WebKitDOMDocumentFragment,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_fragment_get_last_element_child(
        self_: *mut WebKitDOMDocumentFragment,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_fragment_query_selector(
        self_: *mut WebKitDOMDocumentFragment,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_document_fragment_query_selector_all(
        self_: *mut WebKitDOMDocumentFragment,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNodeList;

    //=========================================================================
    // WebKitDOMDocumentType
    //=========================================================================
    pub fn webkit_dom_document_type_get_type() -> GType;
    pub fn webkit_dom_document_type_get_entities(
        self_: *mut WebKitDOMDocumentType,
    ) -> *mut WebKitDOMNamedNodeMap;
    pub fn webkit_dom_document_type_get_internal_subset(
        self_: *mut WebKitDOMDocumentType,
    ) -> *mut c_char;
    pub fn webkit_dom_document_type_get_name(self_: *mut WebKitDOMDocumentType) -> *mut c_char;
    pub fn webkit_dom_document_type_get_notations(
        self_: *mut WebKitDOMDocumentType,
    ) -> *mut WebKitDOMNamedNodeMap;
    pub fn webkit_dom_document_type_get_public_id(self_: *mut WebKitDOMDocumentType)
        -> *mut c_char;
    pub fn webkit_dom_document_type_get_system_id(self_: *mut WebKitDOMDocumentType)
        -> *mut c_char;

    //=========================================================================
    // WebKitDOMElement
    //=========================================================================
    pub fn webkit_dom_element_get_type() -> GType;
    pub fn webkit_dom_element_blur(self_: *mut WebKitDOMElement);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_closest(
        self_: *mut WebKitDOMElement,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_element_focus(self_: *mut WebKitDOMElement);
    pub fn webkit_dom_element_get_attribute(
        self_: *mut WebKitDOMElement,
        name: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_element_get_attribute_node(
        self_: *mut WebKitDOMElement,
        name: *const c_char,
    ) -> *mut WebKitDOMAttr;
    pub fn webkit_dom_element_get_attribute_node_ns(
        self_: *mut WebKitDOMElement,
        namespaceURI: *const c_char,
        localName: *const c_char,
    ) -> *mut WebKitDOMAttr;
    pub fn webkit_dom_element_get_attribute_ns(
        self_: *mut WebKitDOMElement,
        namespaceURI: *const c_char,
        localName: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_element_get_attributes(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMNamedNodeMap;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_element_get_bounding_client_rect(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMClientRect;
    pub fn webkit_dom_element_get_child_element_count(self_: *mut WebKitDOMElement) -> c_ulong;
    #[cfg(any(feature = "v2_10", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_10")))]
    pub fn webkit_dom_element_get_children(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMHTMLCollection;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_get_class_list(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMDOMTokenList;
    pub fn webkit_dom_element_get_class_name(self_: *mut WebKitDOMElement) -> *mut c_char;
    pub fn webkit_dom_element_get_client_height(self_: *mut WebKitDOMElement) -> c_double;
    pub fn webkit_dom_element_get_client_left(self_: *mut WebKitDOMElement) -> c_double;
    #[cfg(any(feature = "v2_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_18")))]
    pub fn webkit_dom_element_get_client_rects(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMClientRectList;
    pub fn webkit_dom_element_get_client_top(self_: *mut WebKitDOMElement) -> c_double;
    pub fn webkit_dom_element_get_client_width(self_: *mut WebKitDOMElement) -> c_double;
    pub fn webkit_dom_element_get_elements_by_class_name(
        self_: *mut WebKitDOMElement,
        class_name: *const c_char,
    ) -> *mut WebKitDOMNodeList;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_dom_element_get_elements_by_class_name_as_html_collection(
        self_: *mut WebKitDOMElement,
        name: *const c_char,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_element_get_elements_by_tag_name(
        self_: *mut WebKitDOMElement,
        tag_name: *const c_char,
    ) -> *mut WebKitDOMNodeList;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_dom_element_get_elements_by_tag_name_as_html_collection(
        self_: *mut WebKitDOMElement,
        name: *const c_char,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_element_get_elements_by_tag_name_ns(
        self_: *mut WebKitDOMElement,
        namespace_uri: *const c_char,
        tag_name: *const c_char,
    ) -> *mut WebKitDOMNodeList;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_dom_element_get_elements_by_tag_name_ns_as_html_collection(
        self_: *mut WebKitDOMElement,
        namespaceURI: *const c_char,
        localName: *const c_char,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_element_get_first_element_child(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_element_get_id(self_: *mut WebKitDOMElement) -> *mut c_char;
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_dom_element_get_inner_html(self_: *mut WebKitDOMElement) -> *mut c_char;
    pub fn webkit_dom_element_get_last_element_child(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_element_get_local_name(self_: *mut WebKitDOMElement) -> *mut c_char;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_element_get_namespace_uri(self_: *mut WebKitDOMElement) -> *mut c_char;
    pub fn webkit_dom_element_get_next_element_sibling(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_element_get_offset_height(self_: *mut WebKitDOMElement) -> c_double;
    pub fn webkit_dom_element_get_offset_left(self_: *mut WebKitDOMElement) -> c_double;
    pub fn webkit_dom_element_get_offset_parent(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_element_get_offset_top(self_: *mut WebKitDOMElement) -> c_double;
    pub fn webkit_dom_element_get_offset_width(self_: *mut WebKitDOMElement) -> c_double;
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_dom_element_get_outer_html(self_: *mut WebKitDOMElement) -> *mut c_char;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_element_get_prefix(self_: *mut WebKitDOMElement) -> *mut c_char;
    pub fn webkit_dom_element_get_previous_element_sibling(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_element_get_scroll_height(self_: *mut WebKitDOMElement) -> c_long;
    pub fn webkit_dom_element_get_scroll_left(self_: *mut WebKitDOMElement) -> c_long;
    pub fn webkit_dom_element_get_scroll_top(self_: *mut WebKitDOMElement) -> c_long;
    pub fn webkit_dom_element_get_scroll_width(self_: *mut WebKitDOMElement) -> c_long;
    pub fn webkit_dom_element_get_style(
        self_: *mut WebKitDOMElement,
    ) -> *mut WebKitDOMCSSStyleDeclaration;
    pub fn webkit_dom_element_get_tag_name(self_: *mut WebKitDOMElement) -> *mut c_char;
    pub fn webkit_dom_element_get_webkit_region_overset(
        self_: *mut WebKitDOMElement,
    ) -> *mut c_char;
    pub fn webkit_dom_element_has_attribute(
        self_: *mut WebKitDOMElement,
        name: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_element_has_attribute_ns(
        self_: *mut WebKitDOMElement,
        namespaceURI: *const c_char,
        localName: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_element_has_attributes(self_: *mut WebKitDOMElement) -> gboolean;
    pub fn webkit_dom_element_html_input_element_get_auto_filled(
        element: *mut WebKitDOMElement,
    ) -> gboolean;
    #[cfg(any(feature = "v2_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_22")))]
    pub fn webkit_dom_element_html_input_element_is_user_edited(
        element: *mut WebKitDOMElement,
    ) -> gboolean;
    #[cfg(any(feature = "v2_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_22")))]
    pub fn webkit_dom_element_html_input_element_set_auto_filled(
        element: *mut WebKitDOMElement,
        auto_filled: gboolean,
    );
    #[cfg(any(feature = "v2_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_22")))]
    pub fn webkit_dom_element_html_input_element_set_editing_value(
        element: *mut WebKitDOMElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_insert_adjacent_element(
        self_: *mut WebKitDOMElement,
        where_: *const c_char,
        element: *mut WebKitDOMElement,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMElement;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_insert_adjacent_html(
        self_: *mut WebKitDOMElement,
        where_: *const c_char,
        html: *const c_char,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_insert_adjacent_text(
        self_: *mut WebKitDOMElement,
        where_: *const c_char,
        text: *const c_char,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_matches(
        self_: *mut WebKitDOMElement,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn webkit_dom_element_query_selector(
        self_: *mut WebKitDOMElement,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMElement;
    pub fn webkit_dom_element_query_selector_all(
        self_: *mut WebKitDOMElement,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNodeList;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_remove(self_: *mut WebKitDOMElement, error: *mut *mut glib::GError);
    pub fn webkit_dom_element_remove_attribute(self_: *mut WebKitDOMElement, name: *const c_char);
    pub fn webkit_dom_element_remove_attribute_node(
        self_: *mut WebKitDOMElement,
        oldAttr: *mut WebKitDOMAttr,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMAttr;
    pub fn webkit_dom_element_remove_attribute_ns(
        self_: *mut WebKitDOMElement,
        namespaceURI: *const c_char,
        localName: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_request_pointer_lock(self_: *mut WebKitDOMElement);
    pub fn webkit_dom_element_scroll_by_lines(self_: *mut WebKitDOMElement, lines: c_long);
    pub fn webkit_dom_element_scroll_by_pages(self_: *mut WebKitDOMElement, pages: c_long);
    pub fn webkit_dom_element_scroll_into_view(
        self_: *mut WebKitDOMElement,
        alignWithTop: gboolean,
    );
    pub fn webkit_dom_element_scroll_into_view_if_needed(
        self_: *mut WebKitDOMElement,
        centerIfNeeded: gboolean,
    );
    pub fn webkit_dom_element_set_attribute(
        self_: *mut WebKitDOMElement,
        name: *const c_char,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_element_set_attribute_node(
        self_: *mut WebKitDOMElement,
        newAttr: *mut WebKitDOMAttr,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMAttr;
    pub fn webkit_dom_element_set_attribute_node_ns(
        self_: *mut WebKitDOMElement,
        newAttr: *mut WebKitDOMAttr,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMAttr;
    pub fn webkit_dom_element_set_attribute_ns(
        self_: *mut WebKitDOMElement,
        namespaceURI: *const c_char,
        qualifiedName: *const c_char,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_element_set_class_name(self_: *mut WebKitDOMElement, value: *const c_char);
    pub fn webkit_dom_element_set_id(self_: *mut WebKitDOMElement, value: *const c_char);
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_dom_element_set_inner_html(
        self_: *mut WebKitDOMElement,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_dom_element_set_outer_html(
        self_: *mut WebKitDOMElement,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_element_set_scroll_left(self_: *mut WebKitDOMElement, value: c_long);
    pub fn webkit_dom_element_set_scroll_top(self_: *mut WebKitDOMElement, value: c_long);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_webkit_matches_selector(
        self_: *mut WebKitDOMElement,
        selectors: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_element_webkit_request_fullscreen(self_: *mut WebKitDOMElement);

    //=========================================================================
    // WebKitDOMEntityReference
    //=========================================================================
    pub fn webkit_dom_entity_reference_get_type() -> GType;

    //=========================================================================
    // WebKitDOMEvent
    //=========================================================================
    pub fn webkit_dom_event_get_type() -> GType;
    pub fn webkit_dom_event_get_bubbles(self_: *mut WebKitDOMEvent) -> gboolean;
    pub fn webkit_dom_event_get_cancel_bubble(self_: *mut WebKitDOMEvent) -> gboolean;
    pub fn webkit_dom_event_get_cancelable(self_: *mut WebKitDOMEvent) -> gboolean;
    pub fn webkit_dom_event_get_current_target(
        self_: *mut WebKitDOMEvent,
    ) -> *mut WebKitDOMEventTarget;
    pub fn webkit_dom_event_get_event_phase(self_: *mut WebKitDOMEvent) -> c_ushort;
    pub fn webkit_dom_event_get_event_type(self_: *mut WebKitDOMEvent) -> *mut c_char;
    pub fn webkit_dom_event_get_return_value(self_: *mut WebKitDOMEvent) -> gboolean;
    pub fn webkit_dom_event_get_src_element(
        self_: *mut WebKitDOMEvent,
    ) -> *mut WebKitDOMEventTarget;
    pub fn webkit_dom_event_get_target(self_: *mut WebKitDOMEvent) -> *mut WebKitDOMEventTarget;
    pub fn webkit_dom_event_get_time_stamp(self_: *mut WebKitDOMEvent) -> u32;
    pub fn webkit_dom_event_init_event(
        self_: *mut WebKitDOMEvent,
        eventTypeArg: *const c_char,
        canBubbleArg: gboolean,
        cancelableArg: gboolean,
    );
    pub fn webkit_dom_event_prevent_default(self_: *mut WebKitDOMEvent);
    pub fn webkit_dom_event_set_cancel_bubble(self_: *mut WebKitDOMEvent, value: gboolean);
    pub fn webkit_dom_event_set_return_value(self_: *mut WebKitDOMEvent, value: gboolean);
    pub fn webkit_dom_event_stop_propagation(self_: *mut WebKitDOMEvent);

    //=========================================================================
    // WebKitDOMFile
    //=========================================================================
    pub fn webkit_dom_file_get_type() -> GType;
    pub fn webkit_dom_file_get_name(self_: *mut WebKitDOMFile) -> *mut c_char;

    //=========================================================================
    // WebKitDOMFileList
    //=========================================================================
    pub fn webkit_dom_file_list_get_type() -> GType;
    pub fn webkit_dom_file_list_get_length(self_: *mut WebKitDOMFileList) -> c_ulong;
    pub fn webkit_dom_file_list_item(
        self_: *mut WebKitDOMFileList,
        index: c_ulong,
    ) -> *mut WebKitDOMFile;

    //=========================================================================
    // WebKitDOMHTMLAnchorElement
    //=========================================================================
    pub fn webkit_dom_html_anchor_element_get_type() -> GType;
    pub fn webkit_dom_html_anchor_element_get_charset(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_coords(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_hash(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_host(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_hostname(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_href(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_hreflang(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_name(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_pathname(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_port(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_protocol(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_rel(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_rev(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_search(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_shape(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_target(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_text(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_get_type_attr(
        self_: *mut WebKitDOMHTMLAnchorElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_anchor_element_set_charset(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_coords(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_hash(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_host(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_hostname(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_href(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_hreflang(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_name(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_pathname(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_port(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_protocol(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_rel(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_rev(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_search(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_shape(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_target(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_anchor_element_set_text(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_anchor_element_set_type_attr(
        self_: *mut WebKitDOMHTMLAnchorElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLAppletElement
    //=========================================================================
    pub fn webkit_dom_html_applet_element_get_type() -> GType;
    pub fn webkit_dom_html_applet_element_get_align(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_alt(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_archive(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_code(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_code_base(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_height(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_hspace(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> c_long;
    pub fn webkit_dom_html_applet_element_get_name(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_object(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_get_vspace(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> c_long;
    pub fn webkit_dom_html_applet_element_get_width(
        self_: *mut WebKitDOMHTMLAppletElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_applet_element_set_align(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_alt(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_archive(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_code(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_code_base(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_height(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_hspace(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: c_long,
    );
    pub fn webkit_dom_html_applet_element_set_name(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_object(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_applet_element_set_vspace(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: c_long,
    );
    pub fn webkit_dom_html_applet_element_set_width(
        self_: *mut WebKitDOMHTMLAppletElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLAreaElement
    //=========================================================================
    pub fn webkit_dom_html_area_element_get_type() -> GType;
    pub fn webkit_dom_html_area_element_get_alt(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_coords(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_hash(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_host(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_hostname(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_href(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_no_href(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> gboolean;
    pub fn webkit_dom_html_area_element_get_pathname(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_port(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_protocol(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_search(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_shape(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_get_target(
        self_: *mut WebKitDOMHTMLAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_area_element_set_alt(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_area_element_set_coords(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_area_element_set_hash(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_area_element_set_host(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_area_element_set_hostname(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_area_element_set_href(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_area_element_set_no_href(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: gboolean,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_area_element_set_pathname(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_area_element_set_port(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_area_element_set_protocol(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_area_element_set_search(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_area_element_set_shape(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_area_element_set_target(
        self_: *mut WebKitDOMHTMLAreaElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLBRElement
    //=========================================================================
    pub fn webkit_dom_html_br_element_get_type() -> GType;
    pub fn webkit_dom_html_br_element_get_clear(self_: *mut WebKitDOMHTMLBRElement) -> *mut c_char;
    pub fn webkit_dom_html_br_element_set_clear(
        self_: *mut WebKitDOMHTMLBRElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLBaseElement
    //=========================================================================
    pub fn webkit_dom_html_base_element_get_type() -> GType;
    pub fn webkit_dom_html_base_element_get_href(
        self_: *mut WebKitDOMHTMLBaseElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_base_element_get_target(
        self_: *mut WebKitDOMHTMLBaseElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_base_element_set_href(
        self_: *mut WebKitDOMHTMLBaseElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_base_element_set_target(
        self_: *mut WebKitDOMHTMLBaseElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLBaseFontElement
    //=========================================================================
    pub fn webkit_dom_html_base_font_element_get_type() -> GType;
    pub fn webkit_dom_html_base_font_element_get_color(
        self_: *mut WebKitDOMHTMLBaseFontElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_base_font_element_get_face(
        self_: *mut WebKitDOMHTMLBaseFontElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_base_font_element_get_size(
        self_: *mut WebKitDOMHTMLBaseFontElement,
    ) -> c_long;
    pub fn webkit_dom_html_base_font_element_set_color(
        self_: *mut WebKitDOMHTMLBaseFontElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_base_font_element_set_face(
        self_: *mut WebKitDOMHTMLBaseFontElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_base_font_element_set_size(
        self_: *mut WebKitDOMHTMLBaseFontElement,
        value: c_long,
    );

    //=========================================================================
    // WebKitDOMHTMLBodyElement
    //=========================================================================
    pub fn webkit_dom_html_body_element_get_type() -> GType;
    pub fn webkit_dom_html_body_element_get_a_link(
        self_: *mut WebKitDOMHTMLBodyElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_body_element_get_background(
        self_: *mut WebKitDOMHTMLBodyElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_body_element_get_bg_color(
        self_: *mut WebKitDOMHTMLBodyElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_body_element_get_link(
        self_: *mut WebKitDOMHTMLBodyElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_body_element_get_text(
        self_: *mut WebKitDOMHTMLBodyElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_body_element_get_v_link(
        self_: *mut WebKitDOMHTMLBodyElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_body_element_set_a_link(
        self_: *mut WebKitDOMHTMLBodyElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_body_element_set_background(
        self_: *mut WebKitDOMHTMLBodyElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_body_element_set_bg_color(
        self_: *mut WebKitDOMHTMLBodyElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_body_element_set_link(
        self_: *mut WebKitDOMHTMLBodyElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_body_element_set_text(
        self_: *mut WebKitDOMHTMLBodyElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_body_element_set_v_link(
        self_: *mut WebKitDOMHTMLBodyElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLButtonElement
    //=========================================================================
    pub fn webkit_dom_html_button_element_get_type() -> GType;
    pub fn webkit_dom_html_button_element_get_autofocus(
        self_: *mut WebKitDOMHTMLButtonElement,
    ) -> gboolean;
    pub fn webkit_dom_html_button_element_get_button_type(
        self_: *mut WebKitDOMHTMLButtonElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_button_element_get_disabled(
        self_: *mut WebKitDOMHTMLButtonElement,
    ) -> gboolean;
    pub fn webkit_dom_html_button_element_get_form(
        self_: *mut WebKitDOMHTMLButtonElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_button_element_get_name(
        self_: *mut WebKitDOMHTMLButtonElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_button_element_get_value(
        self_: *mut WebKitDOMHTMLButtonElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_button_element_get_will_validate(
        self_: *mut WebKitDOMHTMLButtonElement,
    ) -> gboolean;
    pub fn webkit_dom_html_button_element_set_autofocus(
        self_: *mut WebKitDOMHTMLButtonElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_button_element_set_button_type(
        self_: *mut WebKitDOMHTMLButtonElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_button_element_set_disabled(
        self_: *mut WebKitDOMHTMLButtonElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_button_element_set_name(
        self_: *mut WebKitDOMHTMLButtonElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_button_element_set_value(
        self_: *mut WebKitDOMHTMLButtonElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLCanvasElement
    //=========================================================================
    pub fn webkit_dom_html_canvas_element_get_type() -> GType;
    pub fn webkit_dom_html_canvas_element_get_height(
        self_: *mut WebKitDOMHTMLCanvasElement,
    ) -> c_long;
    pub fn webkit_dom_html_canvas_element_get_width(
        self_: *mut WebKitDOMHTMLCanvasElement,
    ) -> c_long;
    pub fn webkit_dom_html_canvas_element_set_height(
        self_: *mut WebKitDOMHTMLCanvasElement,
        value: c_long,
    );
    pub fn webkit_dom_html_canvas_element_set_width(
        self_: *mut WebKitDOMHTMLCanvasElement,
        value: c_long,
    );

    //=========================================================================
    // WebKitDOMHTMLCollection
    //=========================================================================
    pub fn webkit_dom_html_collection_get_type() -> GType;
    pub fn webkit_dom_html_collection_get_length(self_: *mut WebKitDOMHTMLCollection) -> c_ulong;
    pub fn webkit_dom_html_collection_item(
        self_: *mut WebKitDOMHTMLCollection,
        index: c_ulong,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_html_collection_named_item(
        self_: *mut WebKitDOMHTMLCollection,
        name: *const c_char,
    ) -> *mut WebKitDOMNode;

    //=========================================================================
    // WebKitDOMHTMLDListElement
    //=========================================================================
    pub fn webkit_dom_html_d_list_element_get_type() -> GType;
    pub fn webkit_dom_html_d_list_element_get_compact(
        self_: *mut WebKitDOMHTMLDListElement,
    ) -> gboolean;
    pub fn webkit_dom_html_d_list_element_set_compact(
        self_: *mut WebKitDOMHTMLDListElement,
        value: gboolean,
    );

    //=========================================================================
    // WebKitDOMHTMLDirectoryElement
    //=========================================================================
    pub fn webkit_dom_html_directory_element_get_type() -> GType;
    pub fn webkit_dom_html_directory_element_get_compact(
        self_: *mut WebKitDOMHTMLDirectoryElement,
    ) -> gboolean;
    pub fn webkit_dom_html_directory_element_set_compact(
        self_: *mut WebKitDOMHTMLDirectoryElement,
        value: gboolean,
    );

    //=========================================================================
    // WebKitDOMHTMLDivElement
    //=========================================================================
    pub fn webkit_dom_html_div_element_get_type() -> GType;
    pub fn webkit_dom_html_div_element_get_align(
        self_: *mut WebKitDOMHTMLDivElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_div_element_set_align(
        self_: *mut WebKitDOMHTMLDivElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLDocument
    //=========================================================================
    pub fn webkit_dom_html_document_get_type() -> GType;
    pub fn webkit_dom_html_document_capture_events(self_: *mut WebKitDOMHTMLDocument);
    pub fn webkit_dom_html_document_clear(self_: *mut WebKitDOMHTMLDocument);
    pub fn webkit_dom_html_document_close(self_: *mut WebKitDOMHTMLDocument);
    pub fn webkit_dom_html_document_get_alink_color(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut c_char;
    pub fn webkit_dom_html_document_get_bg_color(self_: *mut WebKitDOMHTMLDocument) -> *mut c_char;
    pub fn webkit_dom_html_document_get_compat_mode(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut c_char;
    pub fn webkit_dom_html_document_get_design_mode(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut c_char;
    pub fn webkit_dom_html_document_get_dir(self_: *mut WebKitDOMHTMLDocument) -> *mut c_char;
    pub fn webkit_dom_html_document_get_embeds(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_document_get_fg_color(self_: *mut WebKitDOMHTMLDocument) -> *mut c_char;
    pub fn webkit_dom_html_document_get_height(self_: *mut WebKitDOMHTMLDocument) -> c_long;
    pub fn webkit_dom_html_document_get_link_color(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut c_char;
    pub fn webkit_dom_html_document_get_plugins(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_document_get_scripts(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_document_get_vlink_color(
        self_: *mut WebKitDOMHTMLDocument,
    ) -> *mut c_char;
    pub fn webkit_dom_html_document_get_width(self_: *mut WebKitDOMHTMLDocument) -> c_long;
    pub fn webkit_dom_html_document_release_events(self_: *mut WebKitDOMHTMLDocument);
    pub fn webkit_dom_html_document_set_alink_color(
        self_: *mut WebKitDOMHTMLDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_html_document_set_bg_color(
        self_: *mut WebKitDOMHTMLDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_html_document_set_design_mode(
        self_: *mut WebKitDOMHTMLDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_html_document_set_dir(
        self_: *mut WebKitDOMHTMLDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_html_document_set_fg_color(
        self_: *mut WebKitDOMHTMLDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_html_document_set_link_color(
        self_: *mut WebKitDOMHTMLDocument,
        value: *const c_char,
    );
    pub fn webkit_dom_html_document_set_vlink_color(
        self_: *mut WebKitDOMHTMLDocument,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLElement
    //=========================================================================
    pub fn webkit_dom_html_element_get_type() -> GType;
    pub fn webkit_dom_html_element_click(self_: *mut WebKitDOMHTMLElement);
    pub fn webkit_dom_html_element_get_access_key(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    pub fn webkit_dom_html_element_get_children(
        self_: *mut WebKitDOMHTMLElement,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_element_get_content_editable(
        self_: *mut WebKitDOMHTMLElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_element_get_dir(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_get_draggable(self_: *mut WebKitDOMHTMLElement) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_get_hidden(self_: *mut WebKitDOMHTMLElement) -> gboolean;
    pub fn webkit_dom_html_element_get_inner_html(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    pub fn webkit_dom_html_element_get_inner_text(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    pub fn webkit_dom_html_element_get_is_content_editable(
        self_: *mut WebKitDOMHTMLElement,
    ) -> gboolean;
    pub fn webkit_dom_html_element_get_lang(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    pub fn webkit_dom_html_element_get_outer_html(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    pub fn webkit_dom_html_element_get_outer_text(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_get_spellcheck(self_: *mut WebKitDOMHTMLElement) -> gboolean;
    pub fn webkit_dom_html_element_get_tab_index(self_: *mut WebKitDOMHTMLElement) -> c_long;
    pub fn webkit_dom_html_element_get_title(self_: *mut WebKitDOMHTMLElement) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_get_translate(self_: *mut WebKitDOMHTMLElement) -> gboolean;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_get_webkitdropzone(
        self_: *mut WebKitDOMHTMLElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_element_set_access_key(
        self_: *mut WebKitDOMHTMLElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_element_set_content_editable(
        self_: *mut WebKitDOMHTMLElement,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_element_set_dir(self_: *mut WebKitDOMHTMLElement, value: *const c_char);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_set_draggable(self_: *mut WebKitDOMHTMLElement, value: gboolean);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_set_hidden(self_: *mut WebKitDOMHTMLElement, value: gboolean);
    pub fn webkit_dom_html_element_set_inner_html(
        self_: *mut WebKitDOMHTMLElement,
        contents: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_element_set_inner_text(
        self_: *mut WebKitDOMHTMLElement,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_element_set_lang(self_: *mut WebKitDOMHTMLElement, value: *const c_char);
    pub fn webkit_dom_html_element_set_outer_html(
        self_: *mut WebKitDOMHTMLElement,
        contents: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_element_set_outer_text(
        self_: *mut WebKitDOMHTMLElement,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_set_spellcheck(
        self_: *mut WebKitDOMHTMLElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_element_set_tab_index(self_: *mut WebKitDOMHTMLElement, value: c_long);
    pub fn webkit_dom_html_element_set_title(
        self_: *mut WebKitDOMHTMLElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_set_translate(self_: *mut WebKitDOMHTMLElement, value: gboolean);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_element_set_webkitdropzone(
        self_: *mut WebKitDOMHTMLElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLEmbedElement
    //=========================================================================
    pub fn webkit_dom_html_embed_element_get_type() -> GType;
    pub fn webkit_dom_html_embed_element_get_align(
        self_: *mut WebKitDOMHTMLEmbedElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_embed_element_get_height(
        self_: *mut WebKitDOMHTMLEmbedElement,
    ) -> c_long;
    pub fn webkit_dom_html_embed_element_get_name(
        self_: *mut WebKitDOMHTMLEmbedElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_embed_element_get_src(
        self_: *mut WebKitDOMHTMLEmbedElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_embed_element_get_type_attr(
        self_: *mut WebKitDOMHTMLEmbedElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_embed_element_get_width(self_: *mut WebKitDOMHTMLEmbedElement)
        -> c_long;
    pub fn webkit_dom_html_embed_element_set_align(
        self_: *mut WebKitDOMHTMLEmbedElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_embed_element_set_height(
        self_: *mut WebKitDOMHTMLEmbedElement,
        value: c_long,
    );
    pub fn webkit_dom_html_embed_element_set_name(
        self_: *mut WebKitDOMHTMLEmbedElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_embed_element_set_src(
        self_: *mut WebKitDOMHTMLEmbedElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_embed_element_set_type_attr(
        self_: *mut WebKitDOMHTMLEmbedElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_embed_element_set_width(
        self_: *mut WebKitDOMHTMLEmbedElement,
        value: c_long,
    );

    //=========================================================================
    // WebKitDOMHTMLFieldSetElement
    //=========================================================================
    pub fn webkit_dom_html_field_set_element_get_type() -> GType;
    pub fn webkit_dom_html_field_set_element_get_form(
        self_: *mut WebKitDOMHTMLFieldSetElement,
    ) -> *mut WebKitDOMHTMLFormElement;

    //=========================================================================
    // WebKitDOMHTMLFontElement
    //=========================================================================
    pub fn webkit_dom_html_font_element_get_type() -> GType;
    pub fn webkit_dom_html_font_element_get_color(
        self_: *mut WebKitDOMHTMLFontElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_font_element_get_face(
        self_: *mut WebKitDOMHTMLFontElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_font_element_get_size(
        self_: *mut WebKitDOMHTMLFontElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_font_element_set_color(
        self_: *mut WebKitDOMHTMLFontElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_font_element_set_face(
        self_: *mut WebKitDOMHTMLFontElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_font_element_set_size(
        self_: *mut WebKitDOMHTMLFontElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLFormElement
    //=========================================================================
    pub fn webkit_dom_html_form_element_get_type() -> GType;
    pub fn webkit_dom_html_form_element_get_accept_charset(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_form_element_get_action(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_form_element_get_elements(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_form_element_get_encoding(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_form_element_get_enctype(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_form_element_get_length(self_: *mut WebKitDOMHTMLFormElement) -> c_long;
    pub fn webkit_dom_html_form_element_get_method(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_form_element_get_name(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_form_element_get_target(
        self_: *mut WebKitDOMHTMLFormElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_form_element_reset(self_: *mut WebKitDOMHTMLFormElement);
    pub fn webkit_dom_html_form_element_set_accept_charset(
        self_: *mut WebKitDOMHTMLFormElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_form_element_set_action(
        self_: *mut WebKitDOMHTMLFormElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_form_element_set_encoding(
        self_: *mut WebKitDOMHTMLFormElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_form_element_set_enctype(
        self_: *mut WebKitDOMHTMLFormElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_form_element_set_method(
        self_: *mut WebKitDOMHTMLFormElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_form_element_set_name(
        self_: *mut WebKitDOMHTMLFormElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_form_element_set_target(
        self_: *mut WebKitDOMHTMLFormElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_form_element_submit(self_: *mut WebKitDOMHTMLFormElement);

    //=========================================================================
    // WebKitDOMHTMLFrameElement
    //=========================================================================
    pub fn webkit_dom_html_frame_element_get_type() -> GType;
    pub fn webkit_dom_html_frame_element_get_content_document(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut WebKitDOMDocument;
    pub fn webkit_dom_html_frame_element_get_content_window(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut WebKitDOMDOMWindow;
    pub fn webkit_dom_html_frame_element_get_frame_border(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_element_get_height(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> c_long;
    pub fn webkit_dom_html_frame_element_get_long_desc(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_element_get_margin_height(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_element_get_margin_width(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_element_get_name(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_element_get_no_resize(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> gboolean;
    pub fn webkit_dom_html_frame_element_get_scrolling(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_element_get_src(
        self_: *mut WebKitDOMHTMLFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_element_get_width(self_: *mut WebKitDOMHTMLFrameElement)
        -> c_long;
    pub fn webkit_dom_html_frame_element_set_frame_border(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_frame_element_set_long_desc(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_frame_element_set_margin_height(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_frame_element_set_margin_width(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_frame_element_set_name(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_frame_element_set_no_resize(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_frame_element_set_scrolling(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_frame_element_set_src(
        self_: *mut WebKitDOMHTMLFrameElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLFrameSetElement
    //=========================================================================
    pub fn webkit_dom_html_frame_set_element_get_type() -> GType;
    pub fn webkit_dom_html_frame_set_element_get_cols(
        self_: *mut WebKitDOMHTMLFrameSetElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_set_element_get_rows(
        self_: *mut WebKitDOMHTMLFrameSetElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_frame_set_element_set_cols(
        self_: *mut WebKitDOMHTMLFrameSetElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_frame_set_element_set_rows(
        self_: *mut WebKitDOMHTMLFrameSetElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLHRElement
    //=========================================================================
    pub fn webkit_dom_html_hr_element_get_type() -> GType;
    pub fn webkit_dom_html_hr_element_get_align(self_: *mut WebKitDOMHTMLHRElement) -> *mut c_char;
    pub fn webkit_dom_html_hr_element_get_no_shade(self_: *mut WebKitDOMHTMLHRElement) -> gboolean;
    pub fn webkit_dom_html_hr_element_get_size(self_: *mut WebKitDOMHTMLHRElement) -> *mut c_char;
    pub fn webkit_dom_html_hr_element_get_width(self_: *mut WebKitDOMHTMLHRElement) -> *mut c_char;
    pub fn webkit_dom_html_hr_element_set_align(
        self_: *mut WebKitDOMHTMLHRElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_hr_element_set_no_shade(
        self_: *mut WebKitDOMHTMLHRElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_hr_element_set_size(
        self_: *mut WebKitDOMHTMLHRElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_hr_element_set_width(
        self_: *mut WebKitDOMHTMLHRElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLHeadElement
    //=========================================================================
    pub fn webkit_dom_html_head_element_get_type() -> GType;
    pub fn webkit_dom_html_head_element_get_profile(
        self_: *mut WebKitDOMHTMLHeadElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_head_element_set_profile(
        self_: *mut WebKitDOMHTMLHeadElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLHeadingElement
    //=========================================================================
    pub fn webkit_dom_html_heading_element_get_type() -> GType;
    pub fn webkit_dom_html_heading_element_get_align(
        self_: *mut WebKitDOMHTMLHeadingElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_heading_element_set_align(
        self_: *mut WebKitDOMHTMLHeadingElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLHtmlElement
    //=========================================================================
    pub fn webkit_dom_html_html_element_get_type() -> GType;
    pub fn webkit_dom_html_html_element_get_version(
        self_: *mut WebKitDOMHTMLHtmlElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_html_element_set_version(
        self_: *mut WebKitDOMHTMLHtmlElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLIFrameElement
    //=========================================================================
    pub fn webkit_dom_html_iframe_element_get_type() -> GType;
    pub fn webkit_dom_html_iframe_element_get_align(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_content_document(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut WebKitDOMDocument;
    pub fn webkit_dom_html_iframe_element_get_content_window(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut WebKitDOMDOMWindow;
    pub fn webkit_dom_html_iframe_element_get_frame_border(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_height(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_long_desc(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_margin_height(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_margin_width(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_name(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_scrolling(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_src(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_get_width(
        self_: *mut WebKitDOMHTMLIFrameElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_iframe_element_set_align(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_frame_border(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_height(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_long_desc(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_margin_height(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_margin_width(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_name(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_scrolling(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_src(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_iframe_element_set_width(
        self_: *mut WebKitDOMHTMLIFrameElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLImageElement
    //=========================================================================
    pub fn webkit_dom_html_image_element_get_type() -> GType;
    pub fn webkit_dom_html_image_element_get_align(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_alt(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_border(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_complete(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> gboolean;
    pub fn webkit_dom_html_image_element_get_height(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> c_long;
    pub fn webkit_dom_html_image_element_get_hspace(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> c_long;
    pub fn webkit_dom_html_image_element_get_is_map(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> gboolean;
    pub fn webkit_dom_html_image_element_get_long_desc(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_lowsrc(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_name(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_natural_height(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> c_long;
    pub fn webkit_dom_html_image_element_get_natural_width(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> c_long;
    pub fn webkit_dom_html_image_element_get_src(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_use_map(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_image_element_get_vspace(
        self_: *mut WebKitDOMHTMLImageElement,
    ) -> c_long;
    pub fn webkit_dom_html_image_element_get_width(self_: *mut WebKitDOMHTMLImageElement)
        -> c_long;
    pub fn webkit_dom_html_image_element_get_x(self_: *mut WebKitDOMHTMLImageElement) -> c_long;
    pub fn webkit_dom_html_image_element_get_y(self_: *mut WebKitDOMHTMLImageElement) -> c_long;
    pub fn webkit_dom_html_image_element_set_align(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_alt(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_border(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_height(
        self_: *mut WebKitDOMHTMLImageElement,
        value: c_long,
    );
    pub fn webkit_dom_html_image_element_set_hspace(
        self_: *mut WebKitDOMHTMLImageElement,
        value: c_long,
    );
    pub fn webkit_dom_html_image_element_set_is_map(
        self_: *mut WebKitDOMHTMLImageElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_image_element_set_long_desc(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_lowsrc(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_name(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_src(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_use_map(
        self_: *mut WebKitDOMHTMLImageElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_image_element_set_vspace(
        self_: *mut WebKitDOMHTMLImageElement,
        value: c_long,
    );
    pub fn webkit_dom_html_image_element_set_width(
        self_: *mut WebKitDOMHTMLImageElement,
        value: c_long,
    );

    //=========================================================================
    // WebKitDOMHTMLInputElement
    //=========================================================================
    pub fn webkit_dom_html_input_element_get_type() -> GType;
    pub fn webkit_dom_html_input_element_get_accept(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_align(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_alt(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_input_element_get_auto_filled(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_autofocus(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_capture(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_html_input_element_get_capture_type(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_checked(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_default_checked(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_default_value(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_disabled(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_files(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut WebKitDOMFileList;
    pub fn webkit_dom_html_input_element_get_form(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_input_element_get_height(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> c_ulong;
    pub fn webkit_dom_html_input_element_get_indeterminate(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_input_type(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_max_length(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> c_long;
    pub fn webkit_dom_html_input_element_get_multiple(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_name(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_input_element_get_read_only(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_get_size(self_: *mut WebKitDOMHTMLInputElement)
        -> c_ulong;
    pub fn webkit_dom_html_input_element_get_src(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_use_map(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_value(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_input_element_get_width(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> c_ulong;
    pub fn webkit_dom_html_input_element_get_will_validate(
        self_: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_is_edited(
        input: *mut WebKitDOMHTMLInputElement,
    ) -> gboolean;
    pub fn webkit_dom_html_input_element_select(self_: *mut WebKitDOMHTMLInputElement);
    pub fn webkit_dom_html_input_element_set_accept(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_align(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_alt(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_input_element_set_auto_filled(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_input_element_set_autofocus(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_input_element_set_capture_type(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_checked(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_input_element_set_default_checked(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_input_element_set_default_value(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_disabled(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_input_element_set_editing_value(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_files(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *mut WebKitDOMFileList,
    );
    pub fn webkit_dom_html_input_element_set_height(
        self_: *mut WebKitDOMHTMLInputElement,
        value: c_ulong,
    );
    pub fn webkit_dom_html_input_element_set_indeterminate(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_input_element_set_input_type(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_max_length(
        self_: *mut WebKitDOMHTMLInputElement,
        value: c_long,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_input_element_set_multiple(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_input_element_set_name(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_read_only(
        self_: *mut WebKitDOMHTMLInputElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_input_element_set_size(
        self_: *mut WebKitDOMHTMLInputElement,
        value: c_ulong,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_input_element_set_src(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_use_map(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_value(
        self_: *mut WebKitDOMHTMLInputElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_input_element_set_width(
        self_: *mut WebKitDOMHTMLInputElement,
        value: c_ulong,
    );

    //=========================================================================
    // WebKitDOMHTMLLIElement
    //=========================================================================
    pub fn webkit_dom_html_li_element_get_type() -> GType;
    pub fn webkit_dom_html_li_element_get_type_attr(
        self_: *mut WebKitDOMHTMLLIElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_li_element_get_value(self_: *mut WebKitDOMHTMLLIElement) -> c_long;
    pub fn webkit_dom_html_li_element_set_type_attr(
        self_: *mut WebKitDOMHTMLLIElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_li_element_set_value(self_: *mut WebKitDOMHTMLLIElement, value: c_long);

    //=========================================================================
    // WebKitDOMHTMLLabelElement
    //=========================================================================
    pub fn webkit_dom_html_label_element_get_type() -> GType;
    pub fn webkit_dom_html_label_element_get_form(
        self_: *mut WebKitDOMHTMLLabelElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_label_element_get_html_for(
        self_: *mut WebKitDOMHTMLLabelElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_label_element_set_html_for(
        self_: *mut WebKitDOMHTMLLabelElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLLegendElement
    //=========================================================================
    pub fn webkit_dom_html_legend_element_get_type() -> GType;
    pub fn webkit_dom_html_legend_element_get_align(
        self_: *mut WebKitDOMHTMLLegendElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_legend_element_get_form(
        self_: *mut WebKitDOMHTMLLegendElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_legend_element_set_align(
        self_: *mut WebKitDOMHTMLLegendElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLLinkElement
    //=========================================================================
    pub fn webkit_dom_html_link_element_get_type() -> GType;
    pub fn webkit_dom_html_link_element_get_charset(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_get_disabled(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> gboolean;
    pub fn webkit_dom_html_link_element_get_href(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_get_hreflang(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_get_media(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_get_rel(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_get_rev(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_get_sheet(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut WebKitDOMStyleSheet;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_link_element_get_sizes(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut WebKitDOMDOMTokenList;
    pub fn webkit_dom_html_link_element_get_target(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_get_type_attr(
        self_: *mut WebKitDOMHTMLLinkElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_link_element_set_charset(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_link_element_set_disabled(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_link_element_set_href(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_link_element_set_hreflang(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_link_element_set_media(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_link_element_set_rel(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_link_element_set_rev(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_link_element_set_sizes(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_link_element_set_target(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_link_element_set_type_attr(
        self_: *mut WebKitDOMHTMLLinkElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLMapElement
    //=========================================================================
    pub fn webkit_dom_html_map_element_get_type() -> GType;
    pub fn webkit_dom_html_map_element_get_areas(
        self_: *mut WebKitDOMHTMLMapElement,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_map_element_get_name(self_: *mut WebKitDOMHTMLMapElement)
        -> *mut c_char;
    pub fn webkit_dom_html_map_element_set_name(
        self_: *mut WebKitDOMHTMLMapElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLMarqueeElement
    //=========================================================================
    pub fn webkit_dom_html_marquee_element_get_type() -> GType;
    pub fn webkit_dom_html_marquee_element_start(self_: *mut WebKitDOMHTMLMarqueeElement);
    pub fn webkit_dom_html_marquee_element_stop(self_: *mut WebKitDOMHTMLMarqueeElement);

    //=========================================================================
    // WebKitDOMHTMLMenuElement
    //=========================================================================
    pub fn webkit_dom_html_menu_element_get_type() -> GType;
    pub fn webkit_dom_html_menu_element_get_compact(
        self_: *mut WebKitDOMHTMLMenuElement,
    ) -> gboolean;
    pub fn webkit_dom_html_menu_element_set_compact(
        self_: *mut WebKitDOMHTMLMenuElement,
        value: gboolean,
    );

    //=========================================================================
    // WebKitDOMHTMLMetaElement
    //=========================================================================
    pub fn webkit_dom_html_meta_element_get_type() -> GType;
    pub fn webkit_dom_html_meta_element_get_content(
        self_: *mut WebKitDOMHTMLMetaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_meta_element_get_http_equiv(
        self_: *mut WebKitDOMHTMLMetaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_meta_element_get_name(
        self_: *mut WebKitDOMHTMLMetaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_meta_element_get_scheme(
        self_: *mut WebKitDOMHTMLMetaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_meta_element_set_content(
        self_: *mut WebKitDOMHTMLMetaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_meta_element_set_http_equiv(
        self_: *mut WebKitDOMHTMLMetaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_meta_element_set_name(
        self_: *mut WebKitDOMHTMLMetaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_meta_element_set_scheme(
        self_: *mut WebKitDOMHTMLMetaElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLModElement
    //=========================================================================
    pub fn webkit_dom_html_mod_element_get_type() -> GType;
    pub fn webkit_dom_html_mod_element_get_cite(self_: *mut WebKitDOMHTMLModElement)
        -> *mut c_char;
    pub fn webkit_dom_html_mod_element_get_date_time(
        self_: *mut WebKitDOMHTMLModElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_mod_element_set_cite(
        self_: *mut WebKitDOMHTMLModElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_mod_element_set_date_time(
        self_: *mut WebKitDOMHTMLModElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLOListElement
    //=========================================================================
    pub fn webkit_dom_html_o_list_element_get_type() -> GType;
    pub fn webkit_dom_html_o_list_element_get_compact(
        self_: *mut WebKitDOMHTMLOListElement,
    ) -> gboolean;
    pub fn webkit_dom_html_o_list_element_get_start(
        self_: *mut WebKitDOMHTMLOListElement,
    ) -> c_long;
    pub fn webkit_dom_html_o_list_element_get_type_attr(
        self_: *mut WebKitDOMHTMLOListElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_o_list_element_set_compact(
        self_: *mut WebKitDOMHTMLOListElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_o_list_element_set_start(
        self_: *mut WebKitDOMHTMLOListElement,
        value: c_long,
    );
    pub fn webkit_dom_html_o_list_element_set_type_attr(
        self_: *mut WebKitDOMHTMLOListElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLObjectElement
    //=========================================================================
    pub fn webkit_dom_html_object_element_get_type() -> GType;
    pub fn webkit_dom_html_object_element_get_align(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_archive(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_border(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_code(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_code_base(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_code_type(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_content_document(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut WebKitDOMDocument;
    pub fn webkit_dom_html_object_element_get_data(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_declare(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> gboolean;
    pub fn webkit_dom_html_object_element_get_form(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_object_element_get_height(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_hspace(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> c_long;
    pub fn webkit_dom_html_object_element_get_name(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_standby(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_type_attr(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_use_map(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_get_vspace(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> c_long;
    pub fn webkit_dom_html_object_element_get_width(
        self_: *mut WebKitDOMHTMLObjectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_object_element_set_align(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_archive(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_border(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_code(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_code_base(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_code_type(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_data(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_declare(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_object_element_set_height(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_hspace(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: c_long,
    );
    pub fn webkit_dom_html_object_element_set_name(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_standby(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_type_attr(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_use_map(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_object_element_set_vspace(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: c_long,
    );
    pub fn webkit_dom_html_object_element_set_width(
        self_: *mut WebKitDOMHTMLObjectElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLOptGroupElement
    //=========================================================================
    pub fn webkit_dom_html_opt_group_element_get_type() -> GType;
    pub fn webkit_dom_html_opt_group_element_get_disabled(
        self_: *mut WebKitDOMHTMLOptGroupElement,
    ) -> gboolean;
    pub fn webkit_dom_html_opt_group_element_get_label(
        self_: *mut WebKitDOMHTMLOptGroupElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_opt_group_element_set_disabled(
        self_: *mut WebKitDOMHTMLOptGroupElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_opt_group_element_set_label(
        self_: *mut WebKitDOMHTMLOptGroupElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLOptionElement
    //=========================================================================
    pub fn webkit_dom_html_option_element_get_type() -> GType;
    pub fn webkit_dom_html_option_element_get_default_selected(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> gboolean;
    pub fn webkit_dom_html_option_element_get_disabled(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> gboolean;
    pub fn webkit_dom_html_option_element_get_form(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_option_element_get_index(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> c_long;
    pub fn webkit_dom_html_option_element_get_label(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_option_element_get_selected(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> gboolean;
    pub fn webkit_dom_html_option_element_get_text(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_option_element_get_value(
        self_: *mut WebKitDOMHTMLOptionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_option_element_set_default_selected(
        self_: *mut WebKitDOMHTMLOptionElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_option_element_set_disabled(
        self_: *mut WebKitDOMHTMLOptionElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_option_element_set_label(
        self_: *mut WebKitDOMHTMLOptionElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_option_element_set_selected(
        self_: *mut WebKitDOMHTMLOptionElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_option_element_set_value(
        self_: *mut WebKitDOMHTMLOptionElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLOptionsCollection
    //=========================================================================
    pub fn webkit_dom_html_options_collection_get_type() -> GType;
    pub fn webkit_dom_html_options_collection_get_length(
        self_: *mut WebKitDOMHTMLOptionsCollection,
    ) -> c_ulong;
    pub fn webkit_dom_html_options_collection_get_selected_index(
        self_: *mut WebKitDOMHTMLOptionsCollection,
    ) -> c_long;
    pub fn webkit_dom_html_options_collection_named_item(
        self_: *mut WebKitDOMHTMLOptionsCollection,
        name: *const c_char,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_html_options_collection_set_selected_index(
        self_: *mut WebKitDOMHTMLOptionsCollection,
        value: c_long,
    );

    //=========================================================================
    // WebKitDOMHTMLParagraphElement
    //=========================================================================
    pub fn webkit_dom_html_paragraph_element_get_type() -> GType;
    pub fn webkit_dom_html_paragraph_element_get_align(
        self_: *mut WebKitDOMHTMLParagraphElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_paragraph_element_set_align(
        self_: *mut WebKitDOMHTMLParagraphElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLParamElement
    //=========================================================================
    pub fn webkit_dom_html_param_element_get_type() -> GType;
    pub fn webkit_dom_html_param_element_get_name(
        self_: *mut WebKitDOMHTMLParamElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_param_element_get_type_attr(
        self_: *mut WebKitDOMHTMLParamElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_param_element_get_value(
        self_: *mut WebKitDOMHTMLParamElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_param_element_get_value_type(
        self_: *mut WebKitDOMHTMLParamElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_param_element_set_name(
        self_: *mut WebKitDOMHTMLParamElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_param_element_set_type_attr(
        self_: *mut WebKitDOMHTMLParamElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_param_element_set_value(
        self_: *mut WebKitDOMHTMLParamElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_param_element_set_value_type(
        self_: *mut WebKitDOMHTMLParamElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLPreElement
    //=========================================================================
    pub fn webkit_dom_html_pre_element_get_type() -> GType;
    pub fn webkit_dom_html_pre_element_get_width(self_: *mut WebKitDOMHTMLPreElement) -> c_long;
    pub fn webkit_dom_html_pre_element_get_wrap(self_: *mut WebKitDOMHTMLPreElement) -> gboolean;
    pub fn webkit_dom_html_pre_element_set_width(
        self_: *mut WebKitDOMHTMLPreElement,
        value: c_long,
    );
    pub fn webkit_dom_html_pre_element_set_wrap(
        self_: *mut WebKitDOMHTMLPreElement,
        value: gboolean,
    );

    //=========================================================================
    // WebKitDOMHTMLQuoteElement
    //=========================================================================
    pub fn webkit_dom_html_quote_element_get_type() -> GType;
    pub fn webkit_dom_html_quote_element_get_cite(
        self_: *mut WebKitDOMHTMLQuoteElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_quote_element_set_cite(
        self_: *mut WebKitDOMHTMLQuoteElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLScriptElement
    //=========================================================================
    pub fn webkit_dom_html_script_element_get_type() -> GType;
    pub fn webkit_dom_html_script_element_get_charset(
        self_: *mut WebKitDOMHTMLScriptElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_script_element_get_defer(
        self_: *mut WebKitDOMHTMLScriptElement,
    ) -> gboolean;
    pub fn webkit_dom_html_script_element_get_event(
        self_: *mut WebKitDOMHTMLScriptElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_script_element_get_html_for(
        self_: *mut WebKitDOMHTMLScriptElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_script_element_get_src(
        self_: *mut WebKitDOMHTMLScriptElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_script_element_get_text(
        self_: *mut WebKitDOMHTMLScriptElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_script_element_get_type_attr(
        self_: *mut WebKitDOMHTMLScriptElement,
    ) -> *mut c_char;
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_html_script_element_set_charset(
        self_: *mut WebKitDOMHTMLScriptElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_script_element_set_defer(
        self_: *mut WebKitDOMHTMLScriptElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_script_element_set_event(
        self_: *mut WebKitDOMHTMLScriptElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_script_element_set_html_for(
        self_: *mut WebKitDOMHTMLScriptElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_script_element_set_src(
        self_: *mut WebKitDOMHTMLScriptElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_script_element_set_text(
        self_: *mut WebKitDOMHTMLScriptElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_script_element_set_type_attr(
        self_: *mut WebKitDOMHTMLScriptElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLSelectElement
    //=========================================================================
    pub fn webkit_dom_html_select_element_get_type() -> GType;
    pub fn webkit_dom_html_select_element_add(
        self_: *mut WebKitDOMHTMLSelectElement,
        element: *mut WebKitDOMHTMLElement,
        before: *mut WebKitDOMHTMLElement,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_select_element_get_autofocus(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> gboolean;
    pub fn webkit_dom_html_select_element_get_disabled(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> gboolean;
    pub fn webkit_dom_html_select_element_get_form(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_select_element_get_length(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> c_ulong;
    pub fn webkit_dom_html_select_element_get_multiple(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> gboolean;
    pub fn webkit_dom_html_select_element_get_name(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_select_element_get_options(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> *mut WebKitDOMHTMLOptionsCollection;
    pub fn webkit_dom_html_select_element_get_select_type(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_select_element_get_selected_index(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> c_long;
    pub fn webkit_dom_html_select_element_get_size(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> c_long;
    pub fn webkit_dom_html_select_element_get_value(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_select_element_get_will_validate(
        self_: *mut WebKitDOMHTMLSelectElement,
    ) -> gboolean;
    pub fn webkit_dom_html_select_element_item(
        self_: *mut WebKitDOMHTMLSelectElement,
        index: c_ulong,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_html_select_element_named_item(
        self_: *mut WebKitDOMHTMLSelectElement,
        name: *const c_char,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_html_select_element_remove(
        self_: *mut WebKitDOMHTMLSelectElement,
        index: c_long,
    );
    pub fn webkit_dom_html_select_element_set_autofocus(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_select_element_set_disabled(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_select_element_set_length(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: c_ulong,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_select_element_set_multiple(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_select_element_set_name(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_select_element_set_selected_index(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: c_long,
    );
    pub fn webkit_dom_html_select_element_set_size(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: c_long,
    );
    pub fn webkit_dom_html_select_element_set_value(
        self_: *mut WebKitDOMHTMLSelectElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLStyleElement
    //=========================================================================
    pub fn webkit_dom_html_style_element_get_type() -> GType;
    pub fn webkit_dom_html_style_element_get_disabled(
        self_: *mut WebKitDOMHTMLStyleElement,
    ) -> gboolean;
    pub fn webkit_dom_html_style_element_get_media(
        self_: *mut WebKitDOMHTMLStyleElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_style_element_get_sheet(
        self_: *mut WebKitDOMHTMLStyleElement,
    ) -> *mut WebKitDOMStyleSheet;
    pub fn webkit_dom_html_style_element_get_type_attr(
        self_: *mut WebKitDOMHTMLStyleElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_style_element_set_disabled(
        self_: *mut WebKitDOMHTMLStyleElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_style_element_set_media(
        self_: *mut WebKitDOMHTMLStyleElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_style_element_set_type_attr(
        self_: *mut WebKitDOMHTMLStyleElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTableCaptionElement
    //=========================================================================
    pub fn webkit_dom_html_table_caption_element_get_type() -> GType;
    pub fn webkit_dom_html_table_caption_element_get_align(
        self_: *mut WebKitDOMHTMLTableCaptionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_caption_element_set_align(
        self_: *mut WebKitDOMHTMLTableCaptionElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTableCellElement
    //=========================================================================
    pub fn webkit_dom_html_table_cell_element_get_type() -> GType;
    pub fn webkit_dom_html_table_cell_element_get_abbr(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_align(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_axis(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_bg_color(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_cell_index(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> c_long;
    pub fn webkit_dom_html_table_cell_element_get_ch(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_ch_off(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_col_span(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> c_long;
    pub fn webkit_dom_html_table_cell_element_get_headers(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_height(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_no_wrap(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> gboolean;
    pub fn webkit_dom_html_table_cell_element_get_row_span(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> c_long;
    pub fn webkit_dom_html_table_cell_element_get_scope(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_v_align(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_get_width(
        self_: *mut WebKitDOMHTMLTableCellElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_cell_element_set_abbr(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_align(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_axis(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_bg_color(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_ch(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_ch_off(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_col_span(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: c_long,
    );
    pub fn webkit_dom_html_table_cell_element_set_headers(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_height(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_no_wrap(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_table_cell_element_set_row_span(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: c_long,
    );
    pub fn webkit_dom_html_table_cell_element_set_scope(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_v_align(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_cell_element_set_width(
        self_: *mut WebKitDOMHTMLTableCellElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTableColElement
    //=========================================================================
    pub fn webkit_dom_html_table_col_element_get_type() -> GType;
    pub fn webkit_dom_html_table_col_element_get_align(
        self_: *mut WebKitDOMHTMLTableColElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_col_element_get_ch(
        self_: *mut WebKitDOMHTMLTableColElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_col_element_get_ch_off(
        self_: *mut WebKitDOMHTMLTableColElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_col_element_get_span(
        self_: *mut WebKitDOMHTMLTableColElement,
    ) -> c_long;
    pub fn webkit_dom_html_table_col_element_get_v_align(
        self_: *mut WebKitDOMHTMLTableColElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_col_element_get_width(
        self_: *mut WebKitDOMHTMLTableColElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_col_element_set_align(
        self_: *mut WebKitDOMHTMLTableColElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_col_element_set_ch(
        self_: *mut WebKitDOMHTMLTableColElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_col_element_set_ch_off(
        self_: *mut WebKitDOMHTMLTableColElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_col_element_set_span(
        self_: *mut WebKitDOMHTMLTableColElement,
        value: c_long,
    );
    pub fn webkit_dom_html_table_col_element_set_v_align(
        self_: *mut WebKitDOMHTMLTableColElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_col_element_set_width(
        self_: *mut WebKitDOMHTMLTableColElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTableElement
    //=========================================================================
    pub fn webkit_dom_html_table_element_get_type() -> GType;
    pub fn webkit_dom_html_table_element_create_caption(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLElement;
    pub fn webkit_dom_html_table_element_create_t_foot(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLElement;
    pub fn webkit_dom_html_table_element_create_t_head(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLElement;
    pub fn webkit_dom_html_table_element_delete_caption(self_: *mut WebKitDOMHTMLTableElement);
    pub fn webkit_dom_html_table_element_delete_row(
        self_: *mut WebKitDOMHTMLTableElement,
        index: c_long,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_table_element_delete_t_foot(self_: *mut WebKitDOMHTMLTableElement);
    pub fn webkit_dom_html_table_element_delete_t_head(self_: *mut WebKitDOMHTMLTableElement);
    pub fn webkit_dom_html_table_element_get_align(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_get_bg_color(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_get_border(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_get_caption(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLTableCaptionElement;
    pub fn webkit_dom_html_table_element_get_cell_padding(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_get_cell_spacing(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_get_rows(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_table_element_get_rules(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_get_summary(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_get_t_bodies(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_table_element_get_t_foot(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLTableSectionElement;
    pub fn webkit_dom_html_table_element_get_t_head(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut WebKitDOMHTMLTableSectionElement;
    pub fn webkit_dom_html_table_element_get_width(
        self_: *mut WebKitDOMHTMLTableElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_element_insert_row(
        self_: *mut WebKitDOMHTMLTableElement,
        index: c_long,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMHTMLElement;
    pub fn webkit_dom_html_table_element_set_align(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_element_set_bg_color(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_element_set_border(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_element_set_caption(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *mut WebKitDOMHTMLTableCaptionElement,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_table_element_set_cell_padding(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_element_set_cell_spacing(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_element_set_rules(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_element_set_summary(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_element_set_t_foot(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *mut WebKitDOMHTMLTableSectionElement,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_table_element_set_t_head(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *mut WebKitDOMHTMLTableSectionElement,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_table_element_set_width(
        self_: *mut WebKitDOMHTMLTableElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTableRowElement
    //=========================================================================
    pub fn webkit_dom_html_table_row_element_get_type() -> GType;
    pub fn webkit_dom_html_table_row_element_delete_cell(
        self_: *mut WebKitDOMHTMLTableRowElement,
        index: c_long,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_table_row_element_get_align(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_row_element_get_bg_color(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_row_element_get_cells(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_table_row_element_get_ch(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_row_element_get_ch_off(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_row_element_get_row_index(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> c_long;
    pub fn webkit_dom_html_table_row_element_get_section_row_index(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> c_long;
    pub fn webkit_dom_html_table_row_element_get_v_align(
        self_: *mut WebKitDOMHTMLTableRowElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_row_element_insert_cell(
        self_: *mut WebKitDOMHTMLTableRowElement,
        index: c_long,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMHTMLElement;
    pub fn webkit_dom_html_table_row_element_set_align(
        self_: *mut WebKitDOMHTMLTableRowElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_row_element_set_bg_color(
        self_: *mut WebKitDOMHTMLTableRowElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_row_element_set_ch(
        self_: *mut WebKitDOMHTMLTableRowElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_row_element_set_ch_off(
        self_: *mut WebKitDOMHTMLTableRowElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_row_element_set_v_align(
        self_: *mut WebKitDOMHTMLTableRowElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTableSectionElement
    //=========================================================================
    pub fn webkit_dom_html_table_section_element_get_type() -> GType;
    pub fn webkit_dom_html_table_section_element_delete_row(
        self_: *mut WebKitDOMHTMLTableSectionElement,
        index: c_long,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_html_table_section_element_get_align(
        self_: *mut WebKitDOMHTMLTableSectionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_section_element_get_ch(
        self_: *mut WebKitDOMHTMLTableSectionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_section_element_get_ch_off(
        self_: *mut WebKitDOMHTMLTableSectionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_section_element_get_rows(
        self_: *mut WebKitDOMHTMLTableSectionElement,
    ) -> *mut WebKitDOMHTMLCollection;
    pub fn webkit_dom_html_table_section_element_get_v_align(
        self_: *mut WebKitDOMHTMLTableSectionElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_table_section_element_insert_row(
        self_: *mut WebKitDOMHTMLTableSectionElement,
        index: c_long,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMHTMLElement;
    pub fn webkit_dom_html_table_section_element_set_align(
        self_: *mut WebKitDOMHTMLTableSectionElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_section_element_set_ch(
        self_: *mut WebKitDOMHTMLTableSectionElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_section_element_set_ch_off(
        self_: *mut WebKitDOMHTMLTableSectionElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_table_section_element_set_v_align(
        self_: *mut WebKitDOMHTMLTableSectionElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTextAreaElement
    //=========================================================================
    pub fn webkit_dom_html_text_area_element_get_type() -> GType;
    pub fn webkit_dom_html_text_area_element_get_area_type(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_text_area_element_get_autofocus(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> gboolean;
    pub fn webkit_dom_html_text_area_element_get_cols(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> c_long;
    pub fn webkit_dom_html_text_area_element_get_default_value(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_text_area_element_get_disabled(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> gboolean;
    pub fn webkit_dom_html_text_area_element_get_form(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> *mut WebKitDOMHTMLFormElement;
    pub fn webkit_dom_html_text_area_element_get_name(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_text_area_element_get_read_only(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> gboolean;
    pub fn webkit_dom_html_text_area_element_get_rows(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> c_long;
    pub fn webkit_dom_html_text_area_element_get_selection_end(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> c_long;
    pub fn webkit_dom_html_text_area_element_get_selection_start(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> c_long;
    pub fn webkit_dom_html_text_area_element_get_value(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_text_area_element_get_will_validate(
        self_: *mut WebKitDOMHTMLTextAreaElement,
    ) -> gboolean;
    pub fn webkit_dom_html_text_area_element_is_edited(
        input: *mut WebKitDOMHTMLTextAreaElement,
    ) -> gboolean;
    pub fn webkit_dom_html_text_area_element_select(self_: *mut WebKitDOMHTMLTextAreaElement);
    pub fn webkit_dom_html_text_area_element_set_autofocus(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_text_area_element_set_cols(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: c_long,
    );
    pub fn webkit_dom_html_text_area_element_set_default_value(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_text_area_element_set_disabled(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_text_area_element_set_name(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: *const c_char,
    );
    pub fn webkit_dom_html_text_area_element_set_read_only(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_text_area_element_set_rows(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: c_long,
    );
    pub fn webkit_dom_html_text_area_element_set_selection_end(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: c_long,
    );
    pub fn webkit_dom_html_text_area_element_set_selection_range(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        start: c_long,
        end: c_long,
        direction: *const c_char,
    );
    pub fn webkit_dom_html_text_area_element_set_selection_start(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: c_long,
    );
    pub fn webkit_dom_html_text_area_element_set_value(
        self_: *mut WebKitDOMHTMLTextAreaElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLTitleElement
    //=========================================================================
    pub fn webkit_dom_html_title_element_get_type() -> GType;
    pub fn webkit_dom_html_title_element_get_text(
        self_: *mut WebKitDOMHTMLTitleElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_title_element_set_text(
        self_: *mut WebKitDOMHTMLTitleElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMHTMLUListElement
    //=========================================================================
    pub fn webkit_dom_html_u_list_element_get_type() -> GType;
    pub fn webkit_dom_html_u_list_element_get_compact(
        self_: *mut WebKitDOMHTMLUListElement,
    ) -> gboolean;
    pub fn webkit_dom_html_u_list_element_get_type_attr(
        self_: *mut WebKitDOMHTMLUListElement,
    ) -> *mut c_char;
    pub fn webkit_dom_html_u_list_element_set_compact(
        self_: *mut WebKitDOMHTMLUListElement,
        value: gboolean,
    );
    pub fn webkit_dom_html_u_list_element_set_type_attr(
        self_: *mut WebKitDOMHTMLUListElement,
        value: *const c_char,
    );

    //=========================================================================
    // WebKitDOMKeyboardEvent
    //=========================================================================
    pub fn webkit_dom_keyboard_event_get_type() -> GType;
    pub fn webkit_dom_keyboard_event_get_alt_graph_key(
        self_: *mut WebKitDOMKeyboardEvent,
    ) -> gboolean;
    pub fn webkit_dom_keyboard_event_get_alt_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
    pub fn webkit_dom_keyboard_event_get_ctrl_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
    pub fn webkit_dom_keyboard_event_get_key_identifier(
        self_: *mut WebKitDOMKeyboardEvent,
    ) -> *mut c_char;
    pub fn webkit_dom_keyboard_event_get_key_location(
        self_: *mut WebKitDOMKeyboardEvent,
    ) -> c_ulong;
    pub fn webkit_dom_keyboard_event_get_meta_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
    pub fn webkit_dom_keyboard_event_get_modifier_state(
        self_: *mut WebKitDOMKeyboardEvent,
        keyIdentifierArg: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_keyboard_event_get_shift_key(self_: *mut WebKitDOMKeyboardEvent) -> gboolean;
    pub fn webkit_dom_keyboard_event_init_keyboard_event(
        self_: *mut WebKitDOMKeyboardEvent,
        type_: *const c_char,
        canBubble: gboolean,
        cancelable: gboolean,
        view: *mut WebKitDOMDOMWindow,
        keyIdentifier: *const c_char,
        location: c_ulong,
        ctrlKey: gboolean,
        altKey: gboolean,
        shiftKey: gboolean,
        metaKey: gboolean,
        altGraphKey: gboolean,
    );

    //=========================================================================
    // WebKitDOMMediaList
    //=========================================================================
    pub fn webkit_dom_media_list_get_type() -> GType;
    pub fn webkit_dom_media_list_append_medium(
        self_: *mut WebKitDOMMediaList,
        newMedium: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_media_list_delete_medium(
        self_: *mut WebKitDOMMediaList,
        oldMedium: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_media_list_get_length(self_: *mut WebKitDOMMediaList) -> c_ulong;
    pub fn webkit_dom_media_list_get_media_text(self_: *mut WebKitDOMMediaList) -> *mut c_char;
    pub fn webkit_dom_media_list_item(
        self_: *mut WebKitDOMMediaList,
        index: c_ulong,
    ) -> *mut c_char;
    pub fn webkit_dom_media_list_set_media_text(
        self_: *mut WebKitDOMMediaList,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMMouseEvent
    //=========================================================================
    pub fn webkit_dom_mouse_event_get_type() -> GType;
    pub fn webkit_dom_mouse_event_get_alt_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
    pub fn webkit_dom_mouse_event_get_button(self_: *mut WebKitDOMMouseEvent) -> c_ushort;
    pub fn webkit_dom_mouse_event_get_client_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_get_client_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_get_ctrl_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
    pub fn webkit_dom_mouse_event_get_from_element(
        self_: *mut WebKitDOMMouseEvent,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_mouse_event_get_meta_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
    pub fn webkit_dom_mouse_event_get_offset_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_get_offset_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_get_related_target(
        self_: *mut WebKitDOMMouseEvent,
    ) -> *mut WebKitDOMEventTarget;
    pub fn webkit_dom_mouse_event_get_screen_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_get_screen_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_get_shift_key(self_: *mut WebKitDOMMouseEvent) -> gboolean;
    pub fn webkit_dom_mouse_event_get_to_element(
        self_: *mut WebKitDOMMouseEvent,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_mouse_event_get_x(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_get_y(self_: *mut WebKitDOMMouseEvent) -> c_long;
    pub fn webkit_dom_mouse_event_init_mouse_event(
        self_: *mut WebKitDOMMouseEvent,
        type_: *const c_char,
        canBubble: gboolean,
        cancelable: gboolean,
        view: *mut WebKitDOMDOMWindow,
        detail: c_long,
        screenX: c_long,
        screenY: c_long,
        clientX: c_long,
        clientY: c_long,
        ctrlKey: gboolean,
        altKey: gboolean,
        shiftKey: gboolean,
        metaKey: gboolean,
        button: c_ushort,
        relatedTarget: *mut WebKitDOMEventTarget,
    );

    //=========================================================================
    // WebKitDOMNamedNodeMap
    //=========================================================================
    pub fn webkit_dom_named_node_map_get_type() -> GType;
    pub fn webkit_dom_named_node_map_get_length(self_: *mut WebKitDOMNamedNodeMap) -> c_ulong;
    pub fn webkit_dom_named_node_map_get_named_item(
        self_: *mut WebKitDOMNamedNodeMap,
        name: *const c_char,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_named_node_map_get_named_item_ns(
        self_: *mut WebKitDOMNamedNodeMap,
        namespaceURI: *const c_char,
        localName: *const c_char,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_named_node_map_item(
        self_: *mut WebKitDOMNamedNodeMap,
        index: c_ulong,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_named_node_map_remove_named_item(
        self_: *mut WebKitDOMNamedNodeMap,
        name: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_named_node_map_remove_named_item_ns(
        self_: *mut WebKitDOMNamedNodeMap,
        namespaceURI: *const c_char,
        localName: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_named_node_map_set_named_item(
        self_: *mut WebKitDOMNamedNodeMap,
        node: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_named_node_map_set_named_item_ns(
        self_: *mut WebKitDOMNamedNodeMap,
        node: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;

    //=========================================================================
    // WebKitDOMNode
    //=========================================================================
    pub fn webkit_dom_node_get_type() -> GType;
    #[cfg(any(feature = "v2_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_22")))]
    pub fn webkit_dom_node_for_js_value(
        value: *mut java_script_core::JSCValue,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_append_child(
        self_: *mut WebKitDOMNode,
        newChild: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_clone_node(
        self_: *mut WebKitDOMNode,
        deep: gboolean,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    #[cfg(any(feature = "v2_14", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_14")))]
    pub fn webkit_dom_node_clone_node_with_error(
        self_: *mut WebKitDOMNode,
        deep: gboolean,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_compare_document_position(
        self_: *mut WebKitDOMNode,
        other: *mut WebKitDOMNode,
    ) -> c_ushort;
    pub fn webkit_dom_node_contains(
        self_: *mut WebKitDOMNode,
        other: *mut WebKitDOMNode,
    ) -> gboolean;
    pub fn webkit_dom_node_get_base_uri(self_: *mut WebKitDOMNode) -> *mut c_char;
    pub fn webkit_dom_node_get_child_nodes(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNodeList;
    pub fn webkit_dom_node_get_first_child(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_get_last_child(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_get_local_name(self_: *mut WebKitDOMNode) -> *mut c_char;
    pub fn webkit_dom_node_get_namespace_uri(self_: *mut WebKitDOMNode) -> *mut c_char;
    pub fn webkit_dom_node_get_next_sibling(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_get_node_name(self_: *mut WebKitDOMNode) -> *mut c_char;
    pub fn webkit_dom_node_get_node_type(self_: *mut WebKitDOMNode) -> c_ushort;
    pub fn webkit_dom_node_get_node_value(self_: *mut WebKitDOMNode) -> *mut c_char;
    pub fn webkit_dom_node_get_owner_document(self_: *mut WebKitDOMNode) -> *mut WebKitDOMDocument;
    pub fn webkit_dom_node_get_parent_element(self_: *mut WebKitDOMNode) -> *mut WebKitDOMElement;
    pub fn webkit_dom_node_get_parent_node(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_get_prefix(self_: *mut WebKitDOMNode) -> *mut c_char;
    pub fn webkit_dom_node_get_previous_sibling(self_: *mut WebKitDOMNode) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_get_text_content(self_: *mut WebKitDOMNode) -> *mut c_char;
    pub fn webkit_dom_node_has_child_nodes(self_: *mut WebKitDOMNode) -> gboolean;
    pub fn webkit_dom_node_insert_before(
        self_: *mut WebKitDOMNode,
        newChild: *mut WebKitDOMNode,
        refChild: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_is_default_namespace(
        self_: *mut WebKitDOMNode,
        namespaceURI: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_node_is_equal_node(
        self_: *mut WebKitDOMNode,
        other: *mut WebKitDOMNode,
    ) -> gboolean;
    pub fn webkit_dom_node_is_same_node(
        self_: *mut WebKitDOMNode,
        other: *mut WebKitDOMNode,
    ) -> gboolean;
    pub fn webkit_dom_node_is_supported(
        self_: *mut WebKitDOMNode,
        feature: *const c_char,
        version: *const c_char,
    ) -> gboolean;
    pub fn webkit_dom_node_lookup_namespace_uri(
        self_: *mut WebKitDOMNode,
        prefix: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_node_lookup_prefix(
        self_: *mut WebKitDOMNode,
        namespaceURI: *const c_char,
    ) -> *mut c_char;
    pub fn webkit_dom_node_normalize(self_: *mut WebKitDOMNode);
    pub fn webkit_dom_node_remove_child(
        self_: *mut WebKitDOMNode,
        oldChild: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_replace_child(
        self_: *mut WebKitDOMNode,
        newChild: *mut WebKitDOMNode,
        oldChild: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_set_node_value(
        self_: *mut WebKitDOMNode,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_node_set_prefix(
        self_: *mut WebKitDOMNode,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_node_set_text_content(
        self_: *mut WebKitDOMNode,
        value: *const c_char,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMNodeIterator
    //=========================================================================
    pub fn webkit_dom_node_iterator_get_type() -> GType;
    pub fn webkit_dom_node_iterator_detach(self_: *mut WebKitDOMNodeIterator);
    pub fn webkit_dom_node_iterator_get_expand_entity_references(
        self_: *mut WebKitDOMNodeIterator,
    ) -> gboolean;
    pub fn webkit_dom_node_iterator_get_filter(
        self_: *mut WebKitDOMNodeIterator,
    ) -> *mut WebKitDOMNodeFilter;
    pub fn webkit_dom_node_iterator_get_pointer_before_reference_node(
        self_: *mut WebKitDOMNodeIterator,
    ) -> gboolean;
    pub fn webkit_dom_node_iterator_get_reference_node(
        self_: *mut WebKitDOMNodeIterator,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_iterator_get_root(
        self_: *mut WebKitDOMNodeIterator,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_iterator_get_what_to_show(self_: *mut WebKitDOMNodeIterator) -> c_ulong;
    pub fn webkit_dom_node_iterator_next_node(
        self_: *mut WebKitDOMNodeIterator,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_node_iterator_previous_node(
        self_: *mut WebKitDOMNodeIterator,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;

    //=========================================================================
    // WebKitDOMNodeList
    //=========================================================================
    pub fn webkit_dom_node_list_get_type() -> GType;
    pub fn webkit_dom_node_list_get_length(self_: *mut WebKitDOMNodeList) -> c_ulong;
    pub fn webkit_dom_node_list_item(
        self_: *mut WebKitDOMNodeList,
        index: c_ulong,
    ) -> *mut WebKitDOMNode;

    //=========================================================================
    // WebKitDOMObject
    //=========================================================================
    pub fn webkit_dom_object_get_type() -> GType;

    //=========================================================================
    // WebKitDOMProcessingInstruction
    //=========================================================================
    pub fn webkit_dom_processing_instruction_get_type() -> GType;
    pub fn webkit_dom_processing_instruction_get_sheet(
        self_: *mut WebKitDOMProcessingInstruction,
    ) -> *mut WebKitDOMStyleSheet;
    pub fn webkit_dom_processing_instruction_get_target(
        self_: *mut WebKitDOMProcessingInstruction,
    ) -> *mut c_char;

    //=========================================================================
    // WebKitDOMRange
    //=========================================================================
    pub fn webkit_dom_range_get_type() -> GType;
    pub fn webkit_dom_range_clone_contents(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMDocumentFragment;
    pub fn webkit_dom_range_clone_range(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMRange;
    pub fn webkit_dom_range_collapse(
        self_: *mut WebKitDOMRange,
        toStart: gboolean,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_compare_boundary_points(
        self_: *mut WebKitDOMRange,
        how: c_ushort,
        sourceRange: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> c_short;
    pub fn webkit_dom_range_compare_node(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> c_short;
    pub fn webkit_dom_range_compare_point(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        offset: c_long,
        error: *mut *mut glib::GError,
    ) -> c_short;
    pub fn webkit_dom_range_create_contextual_fragment(
        self_: *mut WebKitDOMRange,
        html: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMDocumentFragment;
    pub fn webkit_dom_range_delete_contents(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_detach(self_: *mut WebKitDOMRange, error: *mut *mut glib::GError);
    #[cfg(any(feature = "v2_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_16")))]
    pub fn webkit_dom_range_expand(
        self_: *mut WebKitDOMRange,
        unit: *const c_char,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_extract_contents(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMDocumentFragment;
    pub fn webkit_dom_range_get_collapsed(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn webkit_dom_range_get_common_ancestor_container(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_range_get_end_container(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_range_get_end_offset(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> c_long;
    pub fn webkit_dom_range_get_start_container(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_range_get_start_offset(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> c_long;
    pub fn webkit_dom_range_get_text(self_: *mut WebKitDOMRange) -> *mut c_char;
    pub fn webkit_dom_range_insert_node(
        self_: *mut WebKitDOMRange,
        newNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_intersects_node(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn webkit_dom_range_is_point_in_range(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        offset: c_long,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn webkit_dom_range_select_node(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_select_node_contents(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_set_end(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        offset: c_long,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_set_end_after(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_set_end_before(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_set_start(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        offset: c_long,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_set_start_after(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_set_start_before(
        self_: *mut WebKitDOMRange,
        refNode: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_surround_contents(
        self_: *mut WebKitDOMRange,
        newParent: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );
    pub fn webkit_dom_range_to_string(
        self_: *mut WebKitDOMRange,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;

    //=========================================================================
    // WebKitDOMStyleSheet
    //=========================================================================
    pub fn webkit_dom_style_sheet_get_type() -> GType;
    pub fn webkit_dom_style_sheet_get_content_type(self_: *mut WebKitDOMStyleSheet) -> *mut c_char;
    pub fn webkit_dom_style_sheet_get_disabled(self_: *mut WebKitDOMStyleSheet) -> gboolean;
    pub fn webkit_dom_style_sheet_get_href(self_: *mut WebKitDOMStyleSheet) -> *mut c_char;
    pub fn webkit_dom_style_sheet_get_media(
        self_: *mut WebKitDOMStyleSheet,
    ) -> *mut WebKitDOMMediaList;
    pub fn webkit_dom_style_sheet_get_owner_node(
        self_: *mut WebKitDOMStyleSheet,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_style_sheet_get_parent_style_sheet(
        self_: *mut WebKitDOMStyleSheet,
    ) -> *mut WebKitDOMStyleSheet;
    pub fn webkit_dom_style_sheet_get_title(self_: *mut WebKitDOMStyleSheet) -> *mut c_char;
    pub fn webkit_dom_style_sheet_set_disabled(self_: *mut WebKitDOMStyleSheet, value: gboolean);

    //=========================================================================
    // WebKitDOMStyleSheetList
    //=========================================================================
    pub fn webkit_dom_style_sheet_list_get_type() -> GType;
    pub fn webkit_dom_style_sheet_list_get_length(self_: *mut WebKitDOMStyleSheetList) -> c_ulong;
    pub fn webkit_dom_style_sheet_list_item(
        self_: *mut WebKitDOMStyleSheetList,
        index: c_ulong,
    ) -> *mut WebKitDOMStyleSheet;

    //=========================================================================
    // WebKitDOMText
    //=========================================================================
    pub fn webkit_dom_text_get_type() -> GType;
    pub fn webkit_dom_text_get_whole_text(self_: *mut WebKitDOMText) -> *mut c_char;
    pub fn webkit_dom_text_replace_whole_text(
        self_: *mut WebKitDOMText,
        content: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMText;
    pub fn webkit_dom_text_split_text(
        self_: *mut WebKitDOMText,
        offset: c_ulong,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMText;

    //=========================================================================
    // WebKitDOMTreeWalker
    //=========================================================================
    pub fn webkit_dom_tree_walker_get_type() -> GType;
    pub fn webkit_dom_tree_walker_first_child(
        self_: *mut WebKitDOMTreeWalker,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_get_current_node(
        self_: *mut WebKitDOMTreeWalker,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_get_expand_entity_references(
        self_: *mut WebKitDOMTreeWalker,
    ) -> gboolean;
    pub fn webkit_dom_tree_walker_get_filter(
        self_: *mut WebKitDOMTreeWalker,
    ) -> *mut WebKitDOMNodeFilter;
    pub fn webkit_dom_tree_walker_get_root(self_: *mut WebKitDOMTreeWalker) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_get_what_to_show(self_: *mut WebKitDOMTreeWalker) -> c_ulong;
    pub fn webkit_dom_tree_walker_last_child(self_: *mut WebKitDOMTreeWalker)
        -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_next_node(self_: *mut WebKitDOMTreeWalker) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_next_sibling(
        self_: *mut WebKitDOMTreeWalker,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_parent_node(
        self_: *mut WebKitDOMTreeWalker,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_previous_node(
        self_: *mut WebKitDOMTreeWalker,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_previous_sibling(
        self_: *mut WebKitDOMTreeWalker,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_tree_walker_set_current_node(
        self_: *mut WebKitDOMTreeWalker,
        value: *mut WebKitDOMNode,
        error: *mut *mut glib::GError,
    );

    //=========================================================================
    // WebKitDOMUIEvent
    //=========================================================================
    pub fn webkit_dom_ui_event_get_type() -> GType;
    pub fn webkit_dom_ui_event_get_char_code(self_: *mut WebKitDOMUIEvent) -> c_long;
    pub fn webkit_dom_ui_event_get_detail(self_: *mut WebKitDOMUIEvent) -> c_long;
    pub fn webkit_dom_ui_event_get_key_code(self_: *mut WebKitDOMUIEvent) -> c_long;
    pub fn webkit_dom_ui_event_get_layer_x(self_: *mut WebKitDOMUIEvent) -> c_long;
    pub fn webkit_dom_ui_event_get_layer_y(self_: *mut WebKitDOMUIEvent) -> c_long;
    pub fn webkit_dom_ui_event_get_page_x(self_: *mut WebKitDOMUIEvent) -> c_long;
    pub fn webkit_dom_ui_event_get_page_y(self_: *mut WebKitDOMUIEvent) -> c_long;
    pub fn webkit_dom_ui_event_get_view(self_: *mut WebKitDOMUIEvent) -> *mut WebKitDOMDOMWindow;
    pub fn webkit_dom_ui_event_init_ui_event(
        self_: *mut WebKitDOMUIEvent,
        type_: *const c_char,
        canBubble: gboolean,
        cancelable: gboolean,
        view: *mut WebKitDOMDOMWindow,
        detail: c_long,
    );

    //=========================================================================
    // WebKitDOMWheelEvent
    //=========================================================================
    pub fn webkit_dom_wheel_event_get_type() -> GType;
    pub fn webkit_dom_wheel_event_get_wheel_delta(self_: *mut WebKitDOMWheelEvent) -> c_long;
    pub fn webkit_dom_wheel_event_get_wheel_delta_x(self_: *mut WebKitDOMWheelEvent) -> c_long;
    pub fn webkit_dom_wheel_event_get_wheel_delta_y(self_: *mut WebKitDOMWheelEvent) -> c_long;
    pub fn webkit_dom_wheel_event_init_wheel_event(
        self_: *mut WebKitDOMWheelEvent,
        wheelDeltaX: c_long,
        wheelDeltaY: c_long,
        view: *mut WebKitDOMDOMWindow,
        screenX: c_long,
        screenY: c_long,
        clientX: c_long,
        clientY: c_long,
        ctrlKey: gboolean,
        altKey: gboolean,
        shiftKey: gboolean,
        metaKey: gboolean,
    );

    //=========================================================================
    // WebKitDOMXPathExpression
    //=========================================================================
    pub fn webkit_dom_xpath_expression_get_type() -> GType;
    pub fn webkit_dom_xpath_expression_evaluate(
        self_: *mut WebKitDOMXPathExpression,
        contextNode: *mut WebKitDOMNode,
        type_: c_ushort,
        inResult: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMXPathResult;

    //=========================================================================
    // WebKitDOMXPathResult
    //=========================================================================
    pub fn webkit_dom_xpath_result_get_type() -> GType;
    pub fn webkit_dom_xpath_result_get_boolean_value(
        self_: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn webkit_dom_xpath_result_get_invalid_iterator_state(
        self_: *mut WebKitDOMXPathResult,
    ) -> gboolean;
    pub fn webkit_dom_xpath_result_get_number_value(
        self_: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> c_double;
    pub fn webkit_dom_xpath_result_get_result_type(self_: *mut WebKitDOMXPathResult) -> c_ushort;
    pub fn webkit_dom_xpath_result_get_single_node_value(
        self_: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_xpath_result_get_snapshot_length(
        self_: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> c_ulong;
    pub fn webkit_dom_xpath_result_get_string_value(
        self_: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> *mut c_char;
    pub fn webkit_dom_xpath_result_iterate_next(
        self_: *mut WebKitDOMXPathResult,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;
    pub fn webkit_dom_xpath_result_snapshot_item(
        self_: *mut WebKitDOMXPathResult,
        index: c_ulong,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitDOMNode;

    //=========================================================================
    // WebKitFrame
    //=========================================================================
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_type() -> GType;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_id(frame: *mut WebKitFrame) -> u64;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_javascript_context_for_script_world(
        frame: *mut WebKitFrame,
        world: *mut WebKitScriptWorld,
    ) -> java_script_core::JSGlobalContextRef;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_javascript_global_context(
        frame: *mut WebKitFrame,
    ) -> java_script_core::JSGlobalContextRef;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_js_context(
        frame: *mut WebKitFrame,
    ) -> *mut java_script_core::JSCContext;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_js_context_for_script_world(
        frame: *mut WebKitFrame,
        world: *mut WebKitScriptWorld,
    ) -> *mut java_script_core::JSCContext;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_js_value_for_dom_object(
        frame: *mut WebKitFrame,
        dom_object: *mut WebKitDOMObject,
    ) -> *mut java_script_core::JSCValue;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_js_value_for_dom_object_in_script_world(
        frame: *mut WebKitFrame,
        dom_object: *mut WebKitDOMObject,
        world: *mut WebKitScriptWorld,
    ) -> *mut java_script_core::JSCValue;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_get_uri(frame: *mut WebKitFrame) -> *const c_char;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_frame_is_main_frame(frame: *mut WebKitFrame) -> gboolean;

    //=========================================================================
    // WebKitHitTestResult
    //=========================================================================
    pub fn webkit_hit_test_result_get_type() -> GType;
    pub fn webkit_hit_test_result_context_is_editable(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> gboolean;
    pub fn webkit_hit_test_result_context_is_image(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> gboolean;
    pub fn webkit_hit_test_result_context_is_link(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> gboolean;
    pub fn webkit_hit_test_result_context_is_media(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> gboolean;
    pub fn webkit_hit_test_result_context_is_scrollbar(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> gboolean;
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_hit_test_result_context_is_selection(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> gboolean;
    pub fn webkit_hit_test_result_get_context(hit_test_result: *mut WebKitHitTestResult) -> c_uint;
    pub fn webkit_hit_test_result_get_image_uri(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> *const c_char;
    pub fn webkit_hit_test_result_get_link_label(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> *const c_char;
    pub fn webkit_hit_test_result_get_link_title(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> *const c_char;
    pub fn webkit_hit_test_result_get_link_uri(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> *const c_char;
    pub fn webkit_hit_test_result_get_media_uri(
        hit_test_result: *mut WebKitHitTestResult,
    ) -> *const c_char;

    //=========================================================================
    // WebKitScriptWorld
    //=========================================================================
    pub fn webkit_script_world_get_type() -> GType;
    pub fn webkit_script_world_new() -> *mut WebKitScriptWorld;
    #[cfg(any(feature = "v2_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_22")))]
    pub fn webkit_script_world_new_with_name(name: *const c_char) -> *mut WebKitScriptWorld;
    pub fn webkit_script_world_get_default() -> *mut WebKitScriptWorld;
    #[cfg(any(feature = "v2_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_22")))]
    pub fn webkit_script_world_get_name(world: *mut WebKitScriptWorld) -> *const c_char;

    //=========================================================================
    // WebKitURIRequest
    //=========================================================================
    pub fn webkit_uri_request_get_type() -> GType;
    pub fn webkit_uri_request_new(uri: *const c_char) -> *mut WebKitURIRequest;
    pub fn webkit_uri_request_get_http_headers(
        request: *mut WebKitURIRequest,
    ) -> *mut soup::SoupMessageHeaders;
    #[cfg(any(feature = "v2_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_12")))]
    pub fn webkit_uri_request_get_http_method(request: *mut WebKitURIRequest) -> *const c_char;
    pub fn webkit_uri_request_get_uri(request: *mut WebKitURIRequest) -> *const c_char;
    pub fn webkit_uri_request_set_uri(request: *mut WebKitURIRequest, uri: *const c_char);

    //=========================================================================
    // WebKitURIResponse
    //=========================================================================
    pub fn webkit_uri_response_get_type() -> GType;
    pub fn webkit_uri_response_get_content_length(response: *mut WebKitURIResponse) -> u64;
    #[cfg(any(feature = "v2_6", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_6")))]
    pub fn webkit_uri_response_get_http_headers(
        response: *mut WebKitURIResponse,
    ) -> *mut soup::SoupMessageHeaders;
    pub fn webkit_uri_response_get_mime_type(response: *mut WebKitURIResponse) -> *const c_char;
    pub fn webkit_uri_response_get_status_code(response: *mut WebKitURIResponse) -> c_uint;
    pub fn webkit_uri_response_get_suggested_filename(
        response: *mut WebKitURIResponse,
    ) -> *const c_char;
    pub fn webkit_uri_response_get_uri(response: *mut WebKitURIResponse) -> *const c_char;

    //=========================================================================
    // WebKitUserMessage
    //=========================================================================
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_get_type() -> GType;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_new(
        name: *const c_char,
        parameters: *mut glib::GVariant,
    ) -> *mut WebKitUserMessage;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_new_with_fd_list(
        name: *const c_char,
        parameters: *mut glib::GVariant,
        fd_list: *mut gio::GUnixFDList,
    ) -> *mut WebKitUserMessage;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_error_quark() -> glib::GQuark;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_get_fd_list(
        message: *mut WebKitUserMessage,
    ) -> *mut gio::GUnixFDList;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_get_name(message: *mut WebKitUserMessage) -> *const c_char;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_get_parameters(
        message: *mut WebKitUserMessage,
    ) -> *mut glib::GVariant;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_user_message_send_reply(
        message: *mut WebKitUserMessage,
        reply: *mut WebKitUserMessage,
    );

    //=========================================================================
    // WebKitWebEditor
    //=========================================================================
    #[cfg(any(feature = "v2_10", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_10")))]
    pub fn webkit_web_editor_get_type() -> GType;
    #[cfg(any(feature = "v2_10", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_10")))]
    pub fn webkit_web_editor_get_page(editor: *mut WebKitWebEditor) -> *mut WebKitWebPage;

    //=========================================================================
    // WebKitWebExtension
    //=========================================================================
    pub fn webkit_web_extension_get_type() -> GType;
    pub fn webkit_web_extension_get_page(
        extension: *mut WebKitWebExtension,
        page_id: u64,
    ) -> *mut WebKitWebPage;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_web_extension_send_message_to_context(
        extension: *mut WebKitWebExtension,
        message: *mut WebKitUserMessage,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_web_extension_send_message_to_context_finish(
        extension: *mut WebKitWebExtension,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitUserMessage;

    //=========================================================================
    // WebKitWebHitTestResult
    //=========================================================================
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_web_hit_test_result_get_type() -> GType;
    #[cfg(any(feature = "v2_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_8")))]
    pub fn webkit_web_hit_test_result_get_node(
        hit_test_result: *mut WebKitWebHitTestResult,
    ) -> *mut WebKitDOMNode;

    //=========================================================================
    // WebKitWebPage
    //=========================================================================
    pub fn webkit_web_page_get_type() -> GType;
    pub fn webkit_web_page_get_dom_document(web_page: *mut WebKitWebPage)
        -> *mut WebKitDOMDocument;
    #[cfg(any(feature = "v2_10", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_10")))]
    pub fn webkit_web_page_get_editor(web_page: *mut WebKitWebPage) -> *mut WebKitWebEditor;
    pub fn webkit_web_page_get_id(web_page: *mut WebKitWebPage) -> u64;
    #[cfg(any(feature = "v2_26", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_26")))]
    pub fn webkit_web_page_get_main_frame(web_page: *mut WebKitWebPage) -> *mut WebKitFrame;
    pub fn webkit_web_page_get_uri(web_page: *mut WebKitWebPage) -> *const c_char;
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_web_page_send_message_to_view(
        web_page: *mut WebKitWebPage,
        message: *mut WebKitUserMessage,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(any(feature = "v2_28", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))]
    pub fn webkit_web_page_send_message_to_view_finish(
        web_page: *mut WebKitWebPage,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut WebKitUserMessage;

    //=========================================================================
    // WebKitDOMEventTarget
    //=========================================================================
    pub fn webkit_dom_event_target_get_type() -> GType;
    pub fn webkit_dom_event_target_add_event_listener(
        target: *mut WebKitDOMEventTarget,
        event_name: *const c_char,
        handler: gobject::GCallback,
        use_capture: gboolean,
        user_data: gpointer,
    ) -> gboolean;
    pub fn webkit_dom_event_target_add_event_listener_with_closure(
        target: *mut WebKitDOMEventTarget,
        event_name: *const c_char,
        handler: *mut gobject::GClosure,
        use_capture: gboolean,
    ) -> gboolean;
    pub fn webkit_dom_event_target_dispatch_event(
        target: *mut WebKitDOMEventTarget,
        event: *mut WebKitDOMEvent,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn webkit_dom_event_target_remove_event_listener(
        target: *mut WebKitDOMEventTarget,
        event_name: *const c_char,
        handler: gobject::GCallback,
        use_capture: gboolean,
    ) -> gboolean;
    pub fn webkit_dom_event_target_remove_event_listener_with_closure(
        target: *mut WebKitDOMEventTarget,
        event_name: *const c_char,
        handler: *mut gobject::GClosure,
        use_capture: gboolean,
    ) -> gboolean;

    //=========================================================================
    // WebKitDOMNodeFilter
    //=========================================================================
    pub fn webkit_dom_node_filter_get_type() -> GType;
    pub fn webkit_dom_node_filter_accept_node(
        filter: *mut WebKitDOMNodeFilter,
        node: *mut WebKitDOMNode,
    ) -> c_short;

    //=========================================================================
    // WebKitDOMXPathNSResolver
    //=========================================================================
    pub fn webkit_dom_xpath_ns_resolver_get_type() -> GType;
    pub fn webkit_dom_xpath_ns_resolver_lookup_namespace_uri(
        resolver: *mut WebKitDOMXPathNSResolver,
        prefix: *const c_char,
    ) -> *mut c_char;

}