//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsISessionStore.idl
//


/// `interface nsISessionStore : nsISupports`
///

/// ```text
/// /**
///  * nsISessionStore keeps track of the current browsing state - i.e.
///  * tab history, cookies, scroll state, form data, and window features
///  * - and allows to restore everything into one browser window.
///  *
///  * The nsISessionStore API operates mostly on browser windows and the tabbrowser
///  * tabs contained in them:
///  *
///  * * "Browser windows" are those DOM windows having loaded
///  * chrome://browser/content/browser.xul . From overlays you can just pass the
///  * global |window| object to the API, though (or |top| from a sidebar).
///  * From elsewhere you can get browser windows through the nsIWindowMediator
///  * by looking for "navigator:browser" windows.
///  *
///  * * "Tabbrowser tabs" are all the child nodes of a browser window's
///  * |gBrowser.tabContainer| such as e.g. |gBrowser.selectedTab|.
///  */
/// ```
///

// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsISessionStore {
    vtable: *const nsISessionStoreVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsISessionStore.
unsafe impl XpCom for nsISessionStore {
    const IID: nsIID = nsID(0x4580f5eb, 0x693d, 0x423d,
        [0xb0, 0xce, 0x2c, 0xb2, 0x0a, 0x96, 0x2e, 0x4d]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsISessionStore {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsISessionStore.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsISessionStoreCoerce {
    /// Cheaply cast a value of this type from a `nsISessionStore`.
    fn coerce_from(v: &nsISessionStore) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsISessionStoreCoerce for nsISessionStore {
    #[inline]
    fn coerce_from(v: &nsISessionStore) -> &Self {
        v
    }
}

impl nsISessionStore {
    /// Cast this `nsISessionStore` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISessionStoreCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsISessionStore {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsISessionStoreCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISessionStore) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsISessionStore
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsISessionStoreVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* attribute boolean canRestoreLastSession; */
    pub GetCanRestoreLastSession: unsafe extern "system" fn (this: *const nsISessionStore, aCanRestoreLastSession: *mut bool) -> nsresult,

    /* attribute boolean canRestoreLastSession; */
    pub SetCanRestoreLastSession: unsafe extern "system" fn (this: *const nsISessionStore, aCanRestoreLastSession: bool) -> nsresult,

    /* void restoreLastSession (); */
    pub RestoreLastSession: unsafe extern "system" fn (this: *const nsISessionStore) -> nsresult,

    /* AString getBrowserState (); */
    pub GetBrowserState: unsafe extern "system" fn (this: *const nsISessionStore, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void setBrowserState (in AString aState); */
    pub SetBrowserState: unsafe extern "system" fn (this: *const nsISessionStore, aState: &::nsstring::nsAString) -> nsresult,

    /* AString getWindowState (in nsIDOMWindow aWindow); */
    pub GetWindowState: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void setWindowState (in nsIDOMWindow aWindow, in AString aState, in boolean aOverwrite); */
    pub SetWindowState: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, aState: &::nsstring::nsAString, aOverwrite: bool) -> nsresult,

    /* AString getTabState (in nsIDOMNode aTab); */
    pub GetTabState: unsafe extern "system" fn (this: *const nsISessionStore, aTab: *const nsIDOMNode, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void setTabState (in nsIDOMNode aTab, in AString aState); */
    pub SetTabState: unsafe extern "system" fn (this: *const nsISessionStore, aTab: *const nsIDOMNode, aState: &::nsstring::nsAString) -> nsresult,

    /* nsIDOMNode duplicateTab (in nsIDOMWindow aWindow, in nsIDOMNode aTab, [optional] in long aDelta); */
    pub DuplicateTab: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, aTab: *const nsIDOMNode, aDelta: libc::int32_t, _retval: *mut *const nsIDOMNode) -> nsresult,

    /* unsigned long getClosedTabCount (in nsIDOMWindow aWindow); */
    pub GetClosedTabCount: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, _retval: *mut libc::uint32_t) -> nsresult,

    /* AString getClosedTabData (in nsIDOMWindow aWindow); */
    pub GetClosedTabData: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* nsIDOMNode undoCloseTab (in nsIDOMWindow aWindow, in unsigned long aIndex); */
    pub UndoCloseTab: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMNode) -> nsresult,

    /* nsIDOMNode forgetClosedTab (in nsIDOMWindow aWindow, in unsigned long aIndex); */
    pub ForgetClosedTab: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMNode) -> nsresult,

    /* unsigned long getClosedWindowCount (); */
    pub GetClosedWindowCount: unsafe extern "system" fn (this: *const nsISessionStore, _retval: *mut libc::uint32_t) -> nsresult,

    /* AString getClosedWindowData (); */
    pub GetClosedWindowData: unsafe extern "system" fn (this: *const nsISessionStore, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* nsIDOMWindow undoCloseWindow (in unsigned long aIndex); */
    pub UndoCloseWindow: unsafe extern "system" fn (this: *const nsISessionStore, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMWindow) -> nsresult,

    /* nsIDOMNode forgetClosedWindow (in unsigned long aIndex); */
    pub ForgetClosedWindow: unsafe extern "system" fn (this: *const nsISessionStore, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMNode) -> nsresult,

    /* AString getWindowValue (in nsIDOMWindow aWindow, in AString aKey); */
    pub GetWindowValue: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, aKey: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void setWindowValue (in nsIDOMWindow aWindow, in AString aKey, in jsval aStringValue); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub SetWindowValue: *const ::libc::c_void,

    /* void deleteWindowValue (in nsIDOMWindow aWindow, in AString aKey); */
    pub DeleteWindowValue: unsafe extern "system" fn (this: *const nsISessionStore, aWindow: *const nsIDOMWindow, aKey: &::nsstring::nsAString) -> nsresult,

    /* AString getTabValue (in nsIDOMNode aTab, in AString aKey); */
    pub GetTabValue: unsafe extern "system" fn (this: *const nsISessionStore, aTab: *const nsIDOMNode, aKey: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void setTabValue (in nsIDOMNode aTab, in AString aKey, in jsval aStringValue); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub SetTabValue: *const ::libc::c_void,

    /* void deleteTabValue (in nsIDOMNode aTab, in AString aKey); */
    pub DeleteTabValue: unsafe extern "system" fn (this: *const nsISessionStore, aTab: *const nsIDOMNode, aKey: &::nsstring::nsAString) -> nsresult,

    /* AString getGlobalValue (in AString aKey); */
    pub GetGlobalValue: unsafe extern "system" fn (this: *const nsISessionStore, aKey: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* void setGlobalValue (in AString aKey, in jsval aStringValue); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub SetGlobalValue: *const ::libc::c_void,

    /* void deleteGlobalValue (in AString aKey); */
    pub DeleteGlobalValue: unsafe extern "system" fn (this: *const nsISessionStore, aKey: &::nsstring::nsAString) -> nsresult,

    /* void persistTabAttribute (in AString aName); */
    pub PersistTabAttribute: unsafe extern "system" fn (this: *const nsISessionStore, aName: &::nsstring::nsAString) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsISessionStore {

    /// ```text
    /// /**
    ///    * Is it possible to restore the previous session. Will always be false when
    ///    * in Private Browsing mode.
    ///    */
    /// ```
    ///

    /// `attribute boolean canRestoreLastSession;`
    #[inline]
    pub unsafe fn GetCanRestoreLastSession(&self, aCanRestoreLastSession: *mut bool) -> nsresult {
        ((*self.vtable).GetCanRestoreLastSession)(self, aCanRestoreLastSession)
    }


    /// ```text
    /// /**
    ///    * Is it possible to restore the previous session. Will always be false when
    ///    * in Private Browsing mode.
    ///    */
    /// ```
    ///

    /// `attribute boolean canRestoreLastSession;`
    #[inline]
    pub unsafe fn SetCanRestoreLastSession(&self, aCanRestoreLastSession: bool) -> nsresult {
        ((*self.vtable).SetCanRestoreLastSession)(self, aCanRestoreLastSession)
    }


    /// ```text
    /// /**
    ///    * Restore the previous session if possible. This will not overwrite the
    ///    * current session. Instead the previous session will be merged into the
    ///    * current session. Current windows will be reused if they were windows that
    ///    * pinned tabs were previously restored into. New windows will be opened as
    ///    * needed.
    ///    *
    ///    * Note: This will throw if there is no previous state to restore. Check with
    ///    * canRestoreLastSession first to avoid thrown errors.
    ///    */
    /// ```
    ///

    /// `void restoreLastSession ();`
    #[inline]
    pub unsafe fn RestoreLastSession(&self, ) -> nsresult {
        ((*self.vtable).RestoreLastSession)(self, )
    }


    /// ```text
    /// /**
    ///    * Get the current browsing state.
    ///    * @returns a JSON string representing the session state.
    ///    */
    /// ```
    ///

    /// `AString getBrowserState ();`
    #[inline]
    pub unsafe fn GetBrowserState(&self, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetBrowserState)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Set the browsing state.
    ///    * This will immediately restore the state of the whole application to the state
    ///    * passed in, *replacing* the current session.
    ///    *
    ///    * @param aState is a JSON string representing the session state.
    ///    */
    /// ```
    ///

    /// `void setBrowserState (in AString aState);`
    #[inline]
    pub unsafe fn SetBrowserState(&self, aState: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetBrowserState)(self, aState)
    }


    /// ```text
    /// /**
    ///    * @param aWindow is the browser window whose state is to be returned.
    ///    *
    ///    * @returns a JSON string representing a session state with only one window.
    ///    */
    /// ```
    ///

    /// `AString getWindowState (in nsIDOMWindow aWindow);`
    #[inline]
    pub unsafe fn GetWindowState(&self, aWindow: *const nsIDOMWindow, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetWindowState)(self, aWindow, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aWindow    is the browser window whose state is to be set.
    ///    * @param aState     is a JSON string representing a session state.
    ///    * @param aOverwrite boolean overwrite existing tabs
    ///    */
    /// ```
    ///

    /// `void setWindowState (in nsIDOMWindow aWindow, in AString aState, in boolean aOverwrite);`
    #[inline]
    pub unsafe fn SetWindowState(&self, aWindow: *const nsIDOMWindow, aState: &::nsstring::nsAString, aOverwrite: bool) -> nsresult {
        ((*self.vtable).SetWindowState)(self, aWindow, aState, aOverwrite)
    }


    /// ```text
    /// /**
    ///    * @param aTab is the tabbrowser tab whose state is to be returned.
    ///    *
    ///    * @returns a JSON string representing the state of the tab
    ///    *         (note: doesn't contain cookies - if you need them, use getWindowState instead).
    ///    */
    /// ```
    ///

    /// `AString getTabState (in nsIDOMNode aTab);`
    #[inline]
    pub unsafe fn GetTabState(&self, aTab: *const nsIDOMNode, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetTabState)(self, aTab, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aTab   is the tabbrowser tab whose state is to be set.
    ///    * @param aState is a JSON string representing a session state.
    ///    */
    /// ```
    ///

    /// `void setTabState (in nsIDOMNode aTab, in AString aState);`
    #[inline]
    pub unsafe fn SetTabState(&self, aTab: *const nsIDOMNode, aState: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetTabState)(self, aTab, aState)
    }


    /// ```text
    /// /**
    ///    * Duplicates a given tab as thoroughly as possible.
    ///    *
    ///    * @param aWindow is the browser window into which the tab will be duplicated.
    ///    * @param aTab    is the tabbrowser tab to duplicate (can be from a different window).
    ///    * @param aDelta  is the offset to the history entry to load in the duplicated tab.
    ///    * @returns a reference to the newly created tab.
    ///    */
    /// ```
    ///

    /// `nsIDOMNode duplicateTab (in nsIDOMWindow aWindow, in nsIDOMNode aTab, [optional] in long aDelta);`
    #[inline]
    pub unsafe fn DuplicateTab(&self, aWindow: *const nsIDOMWindow, aTab: *const nsIDOMNode, aDelta: libc::int32_t, _retval: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).DuplicateTab)(self, aWindow, aTab, aDelta, _retval)
    }


    /// ```text
    /// /**
    ///    * Get the number of restore-able tabs for a browser window
    ///    */
    /// ```
    ///

    /// `unsigned long getClosedTabCount (in nsIDOMWindow aWindow);`
    #[inline]
    pub unsafe fn GetClosedTabCount(&self, aWindow: *const nsIDOMWindow, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetClosedTabCount)(self, aWindow, _retval)
    }


    /// ```text
    /// /**
    ///    * Get closed tab data
    ///    *
    ///    * @param aWindow is the browser window for which to get closed tab data
    ///    * @returns a JSON string representing the list of closed tabs.
    ///    */
    /// ```
    ///

    /// `AString getClosedTabData (in nsIDOMWindow aWindow);`
    #[inline]
    pub unsafe fn GetClosedTabData(&self, aWindow: *const nsIDOMWindow, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetClosedTabData)(self, aWindow, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aWindow is the browser window to reopen a closed tab in.
    ///    * @param aIndex  is the index of the tab to be restored (FIFO ordered).
    ///    * @returns a reference to the reopened tab.
    ///    */
    /// ```
    ///

    /// `nsIDOMNode undoCloseTab (in nsIDOMWindow aWindow, in unsigned long aIndex);`
    #[inline]
    pub unsafe fn UndoCloseTab(&self, aWindow: *const nsIDOMWindow, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).UndoCloseTab)(self, aWindow, aIndex, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aWindow is the browser window associated with the closed tab.
    ///    * @param aIndex  is the index of the closed tab to be removed (FIFO ordered).
    ///    */
    /// ```
    ///

    /// `nsIDOMNode forgetClosedTab (in nsIDOMWindow aWindow, in unsigned long aIndex);`
    #[inline]
    pub unsafe fn ForgetClosedTab(&self, aWindow: *const nsIDOMWindow, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).ForgetClosedTab)(self, aWindow, aIndex, _retval)
    }


    /// ```text
    /// /**
    ///    * Get the number of restore-able windows
    ///    */
    /// ```
    ///

    /// `unsigned long getClosedWindowCount ();`
    #[inline]
    pub unsafe fn GetClosedWindowCount(&self, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetClosedWindowCount)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * Get closed windows data
    ///    *
    ///    * @returns a JSON string representing the list of closed windows.
    ///    */
    /// ```
    ///

    /// `AString getClosedWindowData ();`
    #[inline]
    pub unsafe fn GetClosedWindowData(&self, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetClosedWindowData)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aIndex is the index of the windows to be restored (FIFO ordered).
    ///    * @returns the nsIDOMWindow object of the reopened window
    ///    */
    /// ```
    ///

    /// `nsIDOMWindow undoCloseWindow (in unsigned long aIndex);`
    #[inline]
    pub unsafe fn UndoCloseWindow(&self, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMWindow) -> nsresult {
        ((*self.vtable).UndoCloseWindow)(self, aIndex, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aIndex  is the index of the closed window to be removed (FIFO ordered).
    ///    *
    ///    * @throws NS_ERROR_INVALID_ARG
    ///    *   when aIndex does not map to a closed window
    ///    */
    /// ```
    ///

    /// `nsIDOMNode forgetClosedWindow (in unsigned long aIndex);`
    #[inline]
    pub unsafe fn ForgetClosedWindow(&self, aIndex: libc::uint32_t, _retval: *mut *const nsIDOMNode) -> nsresult {
        ((*self.vtable).ForgetClosedWindow)(self, aIndex, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aWindow is the window to get the value for.
    ///    * @param aKey    is the value's name.
    ///    *
    ///    * @returns A string value or an empty string if none is set.
    ///    */
    /// ```
    ///

    /// `AString getWindowValue (in nsIDOMWindow aWindow, in AString aKey);`
    #[inline]
    pub unsafe fn GetWindowValue(&self, aWindow: *const nsIDOMWindow, aKey: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetWindowValue)(self, aWindow, aKey, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aWindow      is the browser window to set the value for.
    ///    * @param aKey         is the value's name.
    ///    * @param aStringValue is the value itself (use JSON.stringify/parse before setting JS objects).
    ///    */
    /// ```
    ///

    /// `void setWindowValue (in nsIDOMWindow aWindow, in AString aKey, in jsval aStringValue);`
    const _SetWindowValue: () = ();

    /// ```text
    /// /**
    ///    * @param aWindow is the browser window to get the value for.
    ///    * @param aKey    is the value's name.
    ///    */
    /// ```
    ///

    /// `void deleteWindowValue (in nsIDOMWindow aWindow, in AString aKey);`
    #[inline]
    pub unsafe fn DeleteWindowValue(&self, aWindow: *const nsIDOMWindow, aKey: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).DeleteWindowValue)(self, aWindow, aKey)
    }


    /// ```text
    /// /**
    ///    * @param aTab is the tabbrowser tab to get the value for.
    ///    * @param aKey is the value's name.
    ///    *
    ///    * @returns A string value or an empty string if none is set.
    ///    */
    /// ```
    ///

    /// `AString getTabValue (in nsIDOMNode aTab, in AString aKey);`
    #[inline]
    pub unsafe fn GetTabValue(&self, aTab: *const nsIDOMNode, aKey: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetTabValue)(self, aTab, aKey, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aTab         is the tabbrowser tab to set the value for.
    ///    * @param aKey         is the value's name.
    ///    * @param aStringValue is the value itself (use JSON.stringify/parse before setting JS objects).
    ///    */
    /// ```
    ///

    /// `void setTabValue (in nsIDOMNode aTab, in AString aKey, in jsval aStringValue);`
    const _SetTabValue: () = ();

    /// ```text
    /// /**
    ///    * @param aTab is the tabbrowser tab to get the value for.
    ///    * @param aKey is the value's name.
    ///    */
    /// ```
    ///

    /// `void deleteTabValue (in nsIDOMNode aTab, in AString aKey);`
    #[inline]
    pub unsafe fn DeleteTabValue(&self, aTab: *const nsIDOMNode, aKey: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).DeleteTabValue)(self, aTab, aKey)
    }


    /// ```text
    /// /**
    ///    * @param aKey is the value's name.
    ///    *
    ///    * @returns A string value or an empty string if none is set.
    ///    */
    /// ```
    ///

    /// `AString getGlobalValue (in AString aKey);`
    #[inline]
    pub unsafe fn GetGlobalValue(&self, aKey: &::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetGlobalValue)(self, aKey, _retval)
    }


    /// ```text
    /// /**
    ///    * @param aKey         is the value's name.
    ///    * @param aStringValue is the value itself (use JSON.stringify/parse before setting JS objects).
    ///    */
    /// ```
    ///

    /// `void setGlobalValue (in AString aKey, in jsval aStringValue);`
    const _SetGlobalValue: () = ();

    /// ```text
    /// /**
    ///    * @param aTab is the browser tab to get the value for.
    ///    * @param aKey is the value's name.
    ///    */
    /// ```
    ///

    /// `void deleteGlobalValue (in AString aKey);`
    #[inline]
    pub unsafe fn DeleteGlobalValue(&self, aKey: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).DeleteGlobalValue)(self, aKey)
    }


    /// ```text
    /// /**
    ///    * @param aName is the name of the attribute to save/restore for all tabbrowser tabs.
    ///    */
    /// ```
    ///

    /// `void persistTabAttribute (in AString aName);`
    #[inline]
    pub unsafe fn PersistTabAttribute(&self, aName: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).PersistTabAttribute)(self, aName)
    }


}