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


/// `interface nsISearchSubmission : nsISupports`
///


// 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 nsISearchSubmission {
    vtable: *const nsISearchSubmissionVTable,

    /// 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 nsISearchSubmission.
unsafe impl XpCom for nsISearchSubmission {
    const IID: nsIID = nsID(0x5799251f, 0x5b55, 0x4df7,
        [0xa9, 0xe7, 0x0c, 0x27, 0x81, 0x2c, 0x46, 0x9a]);
}

// 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 nsISearchSubmission {
    #[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 nsISearchSubmission.
// 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 nsISearchSubmissionCoerce {
    /// Cheaply cast a value of this type from a `nsISearchSubmission`.
    fn coerce_from(v: &nsISearchSubmission) -> &Self;
}

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

impl nsISearchSubmission {
    /// Cast this `nsISearchSubmission` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISearchSubmissionCoerce>(&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 nsISearchSubmission {
    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> nsISearchSubmissionCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISearchSubmission) -> &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 nsISearchSubmission
// 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 nsISearchSubmissionVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* readonly attribute nsIInputStream postData; */
    pub GetPostData: unsafe extern "system" fn (this: *const nsISearchSubmission, aPostData: *mut *const nsIInputStream) -> nsresult,

    /* readonly attribute nsIURI uri; */
    pub GetUri: unsafe extern "system" fn (this: *const nsISearchSubmission, aUri: *mut *const nsIURI) -> 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 nsISearchSubmission {

    /// ```text
    /// /**
    ///    * The POST data associated with a search submission, wrapped in a MIME
    ///    * input stream. May be null.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIInputStream postData;`
    #[inline]
    pub unsafe fn GetPostData(&self, aPostData: *mut *const nsIInputStream) -> nsresult {
        ((*self.vtable).GetPostData)(self, aPostData)
    }


    /// ```text
    /// /**
    ///    * The URI to submit a search to.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIURI uri;`
    #[inline]
    pub unsafe fn GetUri(&self, aUri: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetUri)(self, aUri)
    }


}


/// `interface nsISearchEngine : nsISupports`
///


// 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 nsISearchEngine {
    vtable: *const nsISearchEngineVTable,

    /// 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 nsISearchEngine.
unsafe impl XpCom for nsISearchEngine {
    const IID: nsIID = nsID(0x620bd920, 0x0491, 0x48c8,
        [0x99, 0xa8, 0xd6, 0x04, 0x7e, 0x64, 0x80, 0x2d]);
}

// 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 nsISearchEngine {
    #[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 nsISearchEngine.
// 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 nsISearchEngineCoerce {
    /// Cheaply cast a value of this type from a `nsISearchEngine`.
    fn coerce_from(v: &nsISearchEngine) -> &Self;
}

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

impl nsISearchEngine {
    /// Cast this `nsISearchEngine` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISearchEngineCoerce>(&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 nsISearchEngine {
    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> nsISearchEngineCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISearchEngine) -> &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 nsISearchEngine
// 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 nsISearchEngineVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* nsISearchSubmission getSubmission (in AString data, [optional] in AString responseType, [optional] in AString purpose); */
    pub GetSubmission: unsafe extern "system" fn (this: *const nsISearchEngine, data: &::nsstring::nsAString, responseType: &::nsstring::nsAString, purpose: &::nsstring::nsAString, _retval: *mut *const nsISearchSubmission) -> nsresult,

    /* void addParam (in AString name, in AString value, in AString responseType); */
    pub AddParam: unsafe extern "system" fn (this: *const nsISearchEngine, name: &::nsstring::nsAString, value: &::nsstring::nsAString, responseType: &::nsstring::nsAString) -> nsresult,

    /* boolean supportsResponseType (in AString responseType); */
    pub SupportsResponseType: unsafe extern "system" fn (this: *const nsISearchEngine, responseType: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* AString getIconURLBySize (in long width, in long height); */
    pub GetIconURLBySize: unsafe extern "system" fn (this: *const nsISearchEngine, width: libc::int32_t, height: libc::int32_t, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* jsval getIcons (); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetIcons: *const ::libc::c_void,

    /* void speculativeConnect (in jsval options); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub SpeculativeConnect: *const ::libc::c_void,

    /* attribute AString alias; */
    pub GetAlias: unsafe extern "system" fn (this: *const nsISearchEngine, aAlias: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute AString alias; */
    pub SetAlias: unsafe extern "system" fn (this: *const nsISearchEngine, aAlias: &::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString description; */
    pub GetDescription: unsafe extern "system" fn (this: *const nsISearchEngine, aDescription: &mut ::nsstring::nsAString) -> nsresult,

    /* attribute boolean hidden; */
    pub GetHidden: unsafe extern "system" fn (this: *const nsISearchEngine, aHidden: *mut bool) -> nsresult,

    /* attribute boolean hidden; */
    pub SetHidden: unsafe extern "system" fn (this: *const nsISearchEngine, aHidden: bool) -> nsresult,

    /* readonly attribute nsIURI iconURI; */
    pub GetIconURI: unsafe extern "system" fn (this: *const nsISearchEngine, aIconURI: *mut *const nsIURI) -> nsresult,

    /* readonly attribute AString name; */
    pub GetName: unsafe extern "system" fn (this: *const nsISearchEngine, aName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString searchForm; */
    pub GetSearchForm: unsafe extern "system" fn (this: *const nsISearchEngine, aSearchForm: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString identifier; */
    pub GetIdentifier: unsafe extern "system" fn (this: *const nsISearchEngine, aIdentifier: &mut ::nsstring::nsAString) -> nsresult,

    /* AString getResultDomain ([optional] in AString responseType); */
    pub GetResultDomain: unsafe extern "system" fn (this: *const nsISearchEngine, responseType: &::nsstring::nsAString, _retval: &mut ::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 nsISearchEngine {

    /// ```text
    /// /**
    ///    * Gets a nsISearchSubmission object that contains information about what to
    ///    * send to the search engine, including the URI and postData, if applicable.
    ///    *
    ///    * @param  data
    ///    *         Data to add to the submission object.
    ///    *         i.e. the search terms.
    ///    *
    ///    * @param  responseType [optional]
    ///    *         The MIME type that we'd like to receive in response
    ///    *         to this submission.  If null, will default to "text/html".
    ///    *
    ///    * @param purpose [optional]
    ///    *        A string meant to indicate the context of the search request. This
    ///    *        allows the search service to provide a different nsISearchSubmission
    ///    *        depending on e.g. where the search is triggered in the UI.
    ///    *
    ///    * @returns A nsISearchSubmission object that contains information about what
    ///    *          to send to the search engine.  If no submission can be
    ///    *          obtained for the given responseType, returns null.
    ///    */
    /// ```
    ///

    /// `nsISearchSubmission getSubmission (in AString data, [optional] in AString responseType, [optional] in AString purpose);`
    #[inline]
    pub unsafe fn GetSubmission(&self, data: &::nsstring::nsAString, responseType: &::nsstring::nsAString, purpose: &::nsstring::nsAString, _retval: *mut *const nsISearchSubmission) -> nsresult {
        ((*self.vtable).GetSubmission)(self, data, responseType, purpose, _retval)
    }


    /// ```text
    /// /**
    ///    * Adds a parameter to the search engine's submission data. This should only
    ///    * be called on engines created via addEngineWithDetails.
    ///    *
    ///    * @param name
    ///    *        The parameter's name. Must not be null.
    ///    *
    ///    * @param value
    ///    *        The value to pass. If value is "{searchTerms}", it will be
    ///    *        substituted with the user-entered data when retrieving the
    ///    *        submission. Must not be null.
    ///    *
    ///    * @param responseType
    ///    *        Since an engine can have several different request URLs,
    ///    *        differentiated by response types, this parameter selects
    ///    *        a request to add parameters to.  If null, will default
    ///    *        to "text/html"
    ///    *
    ///    * @throws NS_ERROR_FAILURE if the search engine is read-only.
    ///    * @throws NS_ERROR_INVALID_ARG if name or value are null.
    ///    */
    /// ```
    ///

    /// `void addParam (in AString name, in AString value, in AString responseType);`
    #[inline]
    pub unsafe fn AddParam(&self, name: &::nsstring::nsAString, value: &::nsstring::nsAString, responseType: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).AddParam)(self, name, value, responseType)
    }


    /// ```text
    /// /**
    ///    * Determines whether the engine can return responses in the given
    ///    * MIME type.  Returns true if the engine spec has a URL with the
    ///    * given responseType, false otherwise.
    ///    *
    ///    * @param responseType
    ///    *        The MIME type to check for
    ///    */
    /// ```
    ///

    /// `boolean supportsResponseType (in AString responseType);`
    #[inline]
    pub unsafe fn SupportsResponseType(&self, responseType: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).SupportsResponseType)(self, responseType, _retval)
    }


    /// ```text
    /// /**
    ///    * Returns a string with the URL to an engine's icon matching both width and
    ///    * height. Returns null if icon with specified dimensions is not found.
    ///    *
    ///    * @param width
    ///    *        Width of the requested icon.
    ///    * @param height
    ///    *        Height of the requested icon.
    ///    */
    /// ```
    ///

    /// `AString getIconURLBySize (in long width, in long height);`
    #[inline]
    pub unsafe fn GetIconURLBySize(&self, width: libc::int32_t, height: libc::int32_t, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetIconURLBySize)(self, width, height, _retval)
    }


    /// ```text
    /// /**
    ///    * Gets an array of all available icons. Each entry is an object with
    ///    * width, height and url properties. width and height are numeric and
    ///    * represent the icon's dimensions. url is a string with the URL for
    ///    * the icon.
    ///    */
    /// ```
    ///

    /// `jsval getIcons ();`
    const _GetIcons: () = ();

    /// ```text
    /// /**
    ///    * Opens a speculative connection to the engine's search URI
    ///    * (and suggest URI, if different) to reduce request latency
    ///    *
    ///    * @param  options
    ///    *         An object that must contain the following fields:
    ///    *         {window} the content window for the window performing the search
    ///    *         {originAttributes} the originAttributes for performing the search
    ///    *
    ///    * @throws NS_ERROR_INVALID_ARG if options is omitted or lacks required
    ///    *         elemeents
    ///    */
    /// ```
    ///

    /// `void speculativeConnect (in jsval options);`
    const _SpeculativeConnect: () = ();

    /// ```text
    /// /**
    ///    * An optional shortcut alias for the engine.
    ///    * When non-null, this is a unique identifier.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * An optional shortcut alias for the engine.
    ///    * When non-null, this is a unique identifier.
    ///    */
    /// ```
    ///

    /// `attribute AString alias;`
    #[inline]
    pub unsafe fn SetAlias(&self, aAlias: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).SetAlias)(self, aAlias)
    }


    /// ```text
    /// /**
    ///    * A text description describing the engine.
    ///    */
    /// ```
    ///

    /// `readonly attribute AString description;`
    #[inline]
    pub unsafe fn GetDescription(&self, aDescription: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetDescription)(self, aDescription)
    }


    /// ```text
    /// /**
    ///    * Whether the engine should be hidden from the user.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Whether the engine should be hidden from the user.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * A nsIURI corresponding to the engine's icon, stored locally. May be null.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIURI iconURI;`
    #[inline]
    pub unsafe fn GetIconURI(&self, aIconURI: *mut *const nsIURI) -> nsresult {
        ((*self.vtable).GetIconURI)(self, aIconURI)
    }


    /// ```text
    /// /**
    ///    * The display name of the search engine. This is a unique identifier.
    ///    */
    /// ```
    ///

    /// `readonly attribute AString name;`
    #[inline]
    pub unsafe fn GetName(&self, aName: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetName)(self, aName)
    }


    /// ```text
    /// /**
    ///    * A URL string pointing to the engine's search form.
    ///    */
    /// ```
    ///

    /// `readonly attribute AString searchForm;`
    #[inline]
    pub unsafe fn GetSearchForm(&self, aSearchForm: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetSearchForm)(self, aSearchForm)
    }


    /// ```text
    /// /**
    ///    * An optional unique identifier for this search engine within the context of
    ///    * the distribution, as provided by the distributing entity.
    ///    */
    /// ```
    ///

    /// `readonly attribute AString identifier;`
    #[inline]
    pub unsafe fn GetIdentifier(&self, aIdentifier: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetIdentifier)(self, aIdentifier)
    }


    /// ```text
    /// /**
    ///    * Gets a string representing the hostname from which search results for a
    ///    * given responseType are returned, minus the leading "www." (if present).
    ///    * This can be specified as an url attribute in the engine description file,
    ///    * but will default to host from the <Url>'s template otherwise.
    ///    *
    ///    * @param  responseType [optional]
    ///    *         The MIME type to get resultDomain for.  Defaults to "text/html".
    ///    *
    ///    * @return the resultDomain for the given responseType.
    ///    */
    /// ```
    ///

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


}


/// `interface nsISearchParseSubmissionResult : nsISupports`
///


// 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 nsISearchParseSubmissionResult {
    vtable: *const nsISearchParseSubmissionResultVTable,

    /// 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 nsISearchParseSubmissionResult.
unsafe impl XpCom for nsISearchParseSubmissionResult {
    const IID: nsIID = nsID(0x0dc93e51, 0xa7bf, 0x4a16,
        [0x86, 0x2d, 0x4b, 0x34, 0x69, 0xff, 0x62, 0x06]);
}

// 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 nsISearchParseSubmissionResult {
    #[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 nsISearchParseSubmissionResult.
// 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 nsISearchParseSubmissionResultCoerce {
    /// Cheaply cast a value of this type from a `nsISearchParseSubmissionResult`.
    fn coerce_from(v: &nsISearchParseSubmissionResult) -> &Self;
}

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

impl nsISearchParseSubmissionResult {
    /// Cast this `nsISearchParseSubmissionResult` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISearchParseSubmissionResultCoerce>(&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 nsISearchParseSubmissionResult {
    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> nsISearchParseSubmissionResultCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISearchParseSubmissionResult) -> &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 nsISearchParseSubmissionResult
// 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 nsISearchParseSubmissionResultVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* readonly attribute nsISearchEngine engine; */
    pub GetEngine: unsafe extern "system" fn (this: *const nsISearchParseSubmissionResult, aEngine: *mut *const nsISearchEngine) -> nsresult,

    /* readonly attribute AString terms; */
    pub GetTerms: unsafe extern "system" fn (this: *const nsISearchParseSubmissionResult, aTerms: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute long termsOffset; */
    pub GetTermsOffset: unsafe extern "system" fn (this: *const nsISearchParseSubmissionResult, aTermsOffset: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long termsLength; */
    pub GetTermsLength: unsafe extern "system" fn (this: *const nsISearchParseSubmissionResult, aTermsLength: *mut libc::int32_t) -> 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 nsISearchParseSubmissionResult {

    /// ```text
    /// /**
    ///    * The search engine associated with the URL passed in to
    ///    * nsISearchEngine::parseSubmissionURL, or null if the URL does not represent
    ///    * a search submission.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsISearchEngine engine;`
    #[inline]
    pub unsafe fn GetEngine(&self, aEngine: *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetEngine)(self, aEngine)
    }


    /// ```text
    /// /**
    ///    * String containing the sought terms.  This can be an empty string in case no
    ///    * terms were specified or the URL does not represent a search submission.
    ///    */
    /// ```
    ///

    /// `readonly attribute AString terms;`
    #[inline]
    pub unsafe fn GetTerms(&self, aTerms: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).GetTerms)(self, aTerms)
    }


    /// ```text
    /// /**
    ///    * The offset of the string |terms| in the URL passed in to
    ///    * nsISearchEngine::parseSubmissionURL, or -1 if the URL does not represent
    ///    * a search submission.
    ///    */
    /// ```
    ///

    /// `readonly attribute long termsOffset;`
    #[inline]
    pub unsafe fn GetTermsOffset(&self, aTermsOffset: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetTermsOffset)(self, aTermsOffset)
    }


    /// ```text
    /// /**
    ///    * The length of the |terms| in the original encoding of the URL passed in to
    ///    * nsISearchEngine::parseSubmissionURL. If the search term in the original
    ///    * URL is encoded then this will be bigger than |terms.length|.
    ///    */
    /// ```
    ///

    /// `readonly attribute long termsLength;`
    #[inline]
    pub unsafe fn GetTermsLength(&self, aTermsLength: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetTermsLength)(self, aTermsLength)
    }


}


/// `interface nsISearchInstallCallback : nsISupports`
///


// 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 nsISearchInstallCallback {
    vtable: *const nsISearchInstallCallbackVTable,

    /// 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 nsISearchInstallCallback.
unsafe impl XpCom for nsISearchInstallCallback {
    const IID: nsIID = nsID(0x9fc39136, 0xf08b, 0x46d3,
        [0xb2, 0x32, 0x96, 0xf4, 0xb7, 0xb0, 0xe2, 0x35]);
}

// 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 nsISearchInstallCallback {
    #[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 nsISearchInstallCallback.
// 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 nsISearchInstallCallbackCoerce {
    /// Cheaply cast a value of this type from a `nsISearchInstallCallback`.
    fn coerce_from(v: &nsISearchInstallCallback) -> &Self;
}

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

impl nsISearchInstallCallback {
    /// Cast this `nsISearchInstallCallback` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsISearchInstallCallbackCoerce>(&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 nsISearchInstallCallback {
    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> nsISearchInstallCallbackCoerce for T {
    #[inline]
    fn coerce_from(v: &nsISearchInstallCallback) -> &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 nsISearchInstallCallback
// 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 nsISearchInstallCallbackVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* void onSuccess (in nsISearchEngine engine); */
    pub OnSuccess: unsafe extern "system" fn (this: *const nsISearchInstallCallback, engine: *const nsISearchEngine) -> nsresult,

    /* void onError (in unsigned long errorCode); */
    pub OnError: unsafe extern "system" fn (this: *const nsISearchInstallCallback, errorCode: libc::uint32_t) -> 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 nsISearchInstallCallback {

    pub const ERROR_UNKNOWN_FAILURE: i64 = 1;


    pub const ERROR_DUPLICATE_ENGINE: i64 = 2;

    /// ```text
    /// /**
    ///    * Called to indicate that the engine addition process succeeded.
    ///    *
    ///    * @param engine
    ///    *        The nsISearchEngine object that was added (will not be null).
    ///    */
    /// ```
    ///

    /// `void onSuccess (in nsISearchEngine engine);`
    #[inline]
    pub unsafe fn OnSuccess(&self, engine: *const nsISearchEngine) -> nsresult {
        ((*self.vtable).OnSuccess)(self, engine)
    }


    /// ```text
    /// /**
    ///    * Called to indicate that the engine addition process failed.
    ///    *
    ///    * @param errorCode
    ///    *        One of the ERROR_* values described above indicating the cause of
    ///    *        the failure.
    ///    */
    /// ```
    ///

    /// `void onError (in unsigned long errorCode);`
    #[inline]
    pub unsafe fn OnError(&self, errorCode: libc::uint32_t) -> nsresult {
        ((*self.vtable).OnError)(self, errorCode)
    }


}


/// `interface nsIBrowserSearchInitObserver : nsISupports`
///

/// ```text
/// /**
///  * Callback for asynchronous initialization of nsIBrowserSearchService
///  */
/// ```
///

// 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 nsIBrowserSearchInitObserver {
    vtable: *const nsIBrowserSearchInitObserverVTable,

    /// 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 nsIBrowserSearchInitObserver.
unsafe impl XpCom for nsIBrowserSearchInitObserver {
    const IID: nsIID = nsID(0x02256156, 0x16e4, 0x47f1,
        [0x99, 0x79, 0x76, 0xff, 0x98, 0xce, 0xb5, 0x90]);
}

// 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 nsIBrowserSearchInitObserver {
    #[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 nsIBrowserSearchInitObserver.
// 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 nsIBrowserSearchInitObserverCoerce {
    /// Cheaply cast a value of this type from a `nsIBrowserSearchInitObserver`.
    fn coerce_from(v: &nsIBrowserSearchInitObserver) -> &Self;
}

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

impl nsIBrowserSearchInitObserver {
    /// Cast this `nsIBrowserSearchInitObserver` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIBrowserSearchInitObserverCoerce>(&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 nsIBrowserSearchInitObserver {
    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> nsIBrowserSearchInitObserverCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIBrowserSearchInitObserver) -> &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 nsIBrowserSearchInitObserver
// 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 nsIBrowserSearchInitObserverVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* void onInitComplete (in nsresult aStatus); */
    pub OnInitComplete: unsafe extern "system" fn (this: *const nsIBrowserSearchInitObserver, aStatus: nsresult) -> 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 nsIBrowserSearchInitObserver {

    /// ```text
    /// /**
    ///    * Called once initialization of the browser search service is complete.
    ///    *
    ///    * @param aStatus The status of that service.
    ///    */
    /// ```
    ///

    /// `void onInitComplete (in nsresult aStatus);`
    #[inline]
    pub unsafe fn OnInitComplete(&self, aStatus: nsresult) -> nsresult {
        ((*self.vtable).OnInitComplete)(self, aStatus)
    }


}


/// `interface nsIBrowserSearchService : nsISupports`
///


// 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 nsIBrowserSearchService {
    vtable: *const nsIBrowserSearchServiceVTable,

    /// 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 nsIBrowserSearchService.
unsafe impl XpCom for nsIBrowserSearchService {
    const IID: nsIID = nsID(0x150ef720, 0xbbe2, 0x4169,
        [0xb9, 0xf3, 0xef, 0x7e, 0xc0, 0x65, 0x4c, 0xed]);
}

// 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 nsIBrowserSearchService {
    #[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 nsIBrowserSearchService.
// 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 nsIBrowserSearchServiceCoerce {
    /// Cheaply cast a value of this type from a `nsIBrowserSearchService`.
    fn coerce_from(v: &nsIBrowserSearchService) -> &Self;
}

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

impl nsIBrowserSearchService {
    /// Cast this `nsIBrowserSearchService` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIBrowserSearchServiceCoerce>(&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 nsIBrowserSearchService {
    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> nsIBrowserSearchServiceCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIBrowserSearchService) -> &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 nsIBrowserSearchService
// 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 nsIBrowserSearchServiceVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* void init ([optional] in nsIBrowserSearchInitObserver aObserver); */
    pub Init: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aObserver: *const nsIBrowserSearchInitObserver) -> nsresult,

    /* readonly attribute bool isInitialized; */
    pub GetIsInitialized: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aIsInitialized: *mut bool) -> nsresult,

    /* void resetToOriginalDefaultEngine (); */
    pub ResetToOriginalDefaultEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService) -> nsresult,

    /* boolean hasEngineWithURL (in AString method, in AString url, in jsval formData); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub HasEngineWithURL: *const ::libc::c_void,

    /* void addEngine (in AString engineURL, in long dataType, in AString iconURL, in boolean confirm, [optional] in nsISearchInstallCallback callback, [optional] in AString extensionID); */
    pub AddEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, engineURL: &::nsstring::nsAString, dataType: libc::int32_t, iconURL: &::nsstring::nsAString, confirm: bool, callback: *const nsISearchInstallCallback, extensionID: &::nsstring::nsAString) -> nsresult,

    /* void addEngineWithDetails (in AString name, in jsval iconURL, [optional] in AString alias, [optional] in AString description, [optional] in AString method, [optional] in AString url, [optional] in AString extensionID); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub AddEngineWithDetails: *const ::libc::c_void,

    /* void restoreDefaultEngines (); */
    pub RestoreDefaultEngines: unsafe extern "system" fn (this: *const nsIBrowserSearchService) -> nsresult,

    /* nsISearchEngine getEngineByAlias (in AString alias); */
    pub GetEngineByAlias: unsafe extern "system" fn (this: *const nsIBrowserSearchService, alias: &::nsstring::nsAString, _retval: *mut *const nsISearchEngine) -> nsresult,

    /* nsISearchEngine getEngineByName (in AString aEngineName); */
    pub GetEngineByName: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aEngineName: &::nsstring::nsAString, _retval: *mut *const nsISearchEngine) -> nsresult,

    /* void getEngines ([optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines); */
    pub GetEngines: unsafe extern "system" fn (this: *const nsIBrowserSearchService, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult,

    /* void getVisibleEngines ([optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines); */
    pub GetVisibleEngines: unsafe extern "system" fn (this: *const nsIBrowserSearchService, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult,

    /* void getDefaultEngines ([optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines); */
    pub GetDefaultEngines: unsafe extern "system" fn (this: *const nsIBrowserSearchService, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult,

    /* void getEnginesByExtensionID (in AString extensionID, [optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines); */
    pub GetEnginesByExtensionID: unsafe extern "system" fn (this: *const nsIBrowserSearchService, extensionID: &::nsstring::nsAString, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult,

    /* void moveEngine (in nsISearchEngine engine, in long newIndex); */
    pub MoveEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, engine: *const nsISearchEngine, newIndex: libc::int32_t) -> nsresult,

    /* void removeEngine (in nsISearchEngine engine); */
    pub RemoveEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, engine: *const nsISearchEngine) -> nsresult,

    /* readonly attribute nsISearchEngine originalDefaultEngine; */
    pub GetOriginalDefaultEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aOriginalDefaultEngine: *mut *const nsISearchEngine) -> nsresult,

    /* attribute nsISearchEngine defaultEngine; */
    pub GetDefaultEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aDefaultEngine: *mut *const nsISearchEngine) -> nsresult,

    /* attribute nsISearchEngine defaultEngine; */
    pub SetDefaultEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aDefaultEngine: *const nsISearchEngine) -> nsresult,

    /* attribute nsISearchEngine currentEngine; */
    pub GetCurrentEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aCurrentEngine: *mut *const nsISearchEngine) -> nsresult,

    /* attribute nsISearchEngine currentEngine; */
    pub SetCurrentEngine: unsafe extern "system" fn (this: *const nsIBrowserSearchService, aCurrentEngine: *const nsISearchEngine) -> nsresult,

    /* jsval getDefaultEngineInfo (); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetDefaultEngineInfo: *const ::libc::c_void,

    /* nsISearchParseSubmissionResult parseSubmissionURL (in AString url); */
    pub ParseSubmissionURL: unsafe extern "system" fn (this: *const nsIBrowserSearchService, url: &::nsstring::nsAString, _retval: *mut *const nsISearchParseSubmissionResult) -> 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 nsIBrowserSearchService {

    /// ```text
    /// /**
    ///    * Start asynchronous initialization.
    ///    *
    ///    * The callback is triggered once initialization is complete, which may be
    ///    * immediately, if initialization has already been completed by some previous
    ///    * call to this method. The callback is always invoked asynchronously.
    ///    *
    ///    * @param aObserver An optional object observing the end of initialization.
    ///    */
    /// ```
    ///

    /// `void init ([optional] in nsIBrowserSearchInitObserver aObserver);`
    #[inline]
    pub unsafe fn Init(&self, aObserver: *const nsIBrowserSearchInitObserver) -> nsresult {
        ((*self.vtable).Init)(self, aObserver)
    }


    /// ```text
    /// /**
    ///    * Determine whether initialization has been completed.
    ///    *
    ///    * Clients of the service can use this attribute to quickly determine whether
    ///    * initialization is complete, and decide to trigger some immediate treatment,
    ///    * to launch asynchronous initialization or to bailout.
    ///    *
    ///    * Note that this attribute does not indicate that initialization has succeeded.
    ///    *
    ///    * @return |true| if the search service is now initialized, |false| if
    ///    * initialization has not been triggered yet.
    ///    */
    /// ```
    ///

    /// `readonly attribute bool isInitialized;`
    #[inline]
    pub unsafe fn GetIsInitialized(&self, aIsInitialized: *mut bool) -> nsresult {
        ((*self.vtable).GetIsInitialized)(self, aIsInitialized)
    }


    /// ```text
    /// /**
    ///    * Resets the default engine to its original value.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Checks if an EngineURL of type URLTYPE_SEARCH_HTML exists for
    ///    * any engine, with a matching method, template URL, and query params.
    ///    *
    ///    * @param method
    ///    *        The HTTP request method used when submitting a search query.
    ///    *        Must be a case insensitive value of either "get" or "post".
    ///    *
    ///    * @param url
    ///    *        The URL to which search queries should be sent.
    ///    *        Must not be null.
    ///    *
    ///    * @param formData
    ///    *        The un-sorted form data used as query params.
    ///    */
    /// ```
    ///

    /// `boolean hasEngineWithURL (in AString method, in AString url, in jsval formData);`
    const _HasEngineWithURL: () = ();

    /// ```text
    /// /**
    ///    * Adds a new search engine from the file at the supplied URI, optionally
    ///    * asking the user for confirmation first.  If a confirmation dialog is
    ///    * shown, it will offer the option to begin using the newly added engine
    ///    * right away.
    ///    *
    ///    * @param engineURL
    ///    *        The URL to the search engine's description file.
    ///    *
    ///    * @param dataType
    ///    *        Obsolete, the value is ignored.
    ///    *
    ///    * @param iconURL
    ///    *        A URL string to an icon file to be used as the search engine's
    ///    *        icon. This value may be overridden by an icon specified in the
    ///    *        engine description file.
    ///    *
    ///    * @param confirm
    ///    *        A boolean value indicating whether the user should be asked for
    ///    *        confirmation before this engine is added to the list.  If this
    ///    *        value is false, the engine will be added to the list upon successful
    ///    *        load, but it will not be selected as the current engine.
    ///    *
    ///    * @param callback
    ///    *        A nsISearchInstallCallback that will be notified when the
    ///    *        addition is complete, or if the addition fails. It will not be
    ///    *        called if addEngine throws an exception.
    ///    *
    ///    * @param extensionID [optional]
    ///    *        Optional: The correct extensionID if called by an add-on.
    ///    *
    ///    * @throws NS_ERROR_FAILURE if the description file cannot be successfully
    ///    *         loaded.
    ///    */
    /// ```
    ///

    /// `void addEngine (in AString engineURL, in long dataType, in AString iconURL, in boolean confirm, [optional] in nsISearchInstallCallback callback, [optional] in AString extensionID);`
    #[inline]
    pub unsafe fn AddEngine(&self, engineURL: &::nsstring::nsAString, dataType: libc::int32_t, iconURL: &::nsstring::nsAString, confirm: bool, callback: *const nsISearchInstallCallback, extensionID: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).AddEngine)(self, engineURL, dataType, iconURL, confirm, callback, extensionID)
    }


    /// ```text
    /// /**
    ///    * Adds a new search engine, without asking the user for confirmation and
    ///    * without starting to use it right away.
    ///    *
    ///    * @param name
    ///    *        The search engine's name. Must be unique. Must not be null.
    ///    *
    ///    * @param iconURL
    ///    *        Optional: A URL string pointing to the icon to be used to represent
    ///    *        the engine.
    ///    *        This is a jsval so that an object can be passed to replace the
    ///    *        parameters below.
    ///    *
    ///    * @param alias
    ///    *        Optional: A unique shortcut that can be used to retrieve the
    ///    *        search engine.
    ///    *
    ///    * @param description
    ///    *        Optional: a description of the search engine.
    ///    *
    ///    * @param method
    ///    *        Optional: The HTTP request method used when submitting a search query.
    ///    *        Case insensitive value of either "get" or "post".
    ///    *        Defaults to "get".
    ///    *
    ///    * @param url
    ///    *        The URL to which search queries should be sent.
    ///    *        Must not be null.
    ///    *
    ///    * @param extensionID [optional]
    ///    *        Optional: The correct extensionID if called by an add-on.
    ///    *
    ///    * Alternatively, all of these parameters except for name can be
    ///    * passed as an object in place of parameter two.
    ///    *
    ///    *   Services.search.addEngineWithDetails("Example engine", {
            ///    *     template: "http://example.com/?search={searchTerms}",
            ///    *     description: "Example search engine description",
            ///    *     suggestURL: http://example.com/?suggest={searchTerms},
            ///    * });
    ///    *
    ///    * Using this method, you can use a new parameter, suggestURL:
    ///    *
    ///    * @param suggestURL [optional]
    ///    *        Optional: The URL to which search suggestion requests
    ///    *        should be sent.
    ///    *
    ///    */
    /// ```
    ///

    /// `void addEngineWithDetails (in AString name, in jsval iconURL, [optional] in AString alias, [optional] in AString description, [optional] in AString method, [optional] in AString url, [optional] in AString extensionID);`
    const _AddEngineWithDetails: () = ();

    /// ```text
    /// /**
    ///    * Un-hides all engines in the set of engines returned by getDefaultEngines.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Returns an engine with the specified alias.
    ///    *
    ///    * @param   alias
    ///    *          The search engine's alias.
    ///    * @returns The corresponding nsISearchEngine object, or null if it doesn't
    ///    *          exist.
    ///    */
    /// ```
    ///

    /// `nsISearchEngine getEngineByAlias (in AString alias);`
    #[inline]
    pub unsafe fn GetEngineByAlias(&self, alias: &::nsstring::nsAString, _retval: *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetEngineByAlias)(self, alias, _retval)
    }


    /// ```text
    /// /**
    ///    * Returns an engine with the specified name.
    ///    *
    ///    * @param   aEngineName
    ///    *          The name of the engine.
    ///    * @returns The corresponding nsISearchEngine object, or null if it doesn't
    ///    *          exist.
    ///    */
    /// ```
    ///

    /// `nsISearchEngine getEngineByName (in AString aEngineName);`
    #[inline]
    pub unsafe fn GetEngineByName(&self, aEngineName: &::nsstring::nsAString, _retval: *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetEngineByName)(self, aEngineName, _retval)
    }


    /// ```text
    /// /**
    ///    * Returns an array of all installed search engines.
    ///    *
    ///    * @returns an array of nsISearchEngine objects.
    ///    */
    /// ```
    ///

    /// `void getEngines ([optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines);`
    #[inline]
    pub unsafe fn GetEngines(&self, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetEngines)(self, engineCount, engines)
    }


    /// ```text
    /// /**
    ///    * Returns an array of all installed search engines whose hidden attribute is
    ///    * false.
    ///    *
    ///    * @returns an array of nsISearchEngine objects.
    ///    */
    /// ```
    ///

    /// `void getVisibleEngines ([optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines);`
    #[inline]
    pub unsafe fn GetVisibleEngines(&self, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetVisibleEngines)(self, engineCount, engines)
    }


    /// ```text
    /// /**
    ///    * Returns an array of all default search engines. This includes all loaded
    ///    * engines that aren't in the user's profile directory
    ///    * (NS_APP_USER_SEARCH_DIR).
    ///    *
    ///    * @returns an array of nsISearchEngine objects.
    ///    */
    /// ```
    ///

    /// `void getDefaultEngines ([optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines);`
    #[inline]
    pub unsafe fn GetDefaultEngines(&self, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetDefaultEngines)(self, engineCount, engines)
    }


    /// ```text
    /// /**
    ///    * Returns an array of search engines installed by a given extension.
    ///    *
    ///    * @returns an array of nsISearchEngine objects.
    ///    */
    /// ```
    ///

    /// `void getEnginesByExtensionID (in AString extensionID, [optional] out unsigned long engineCount, [array, size_is (engineCount), retval] out nsISearchEngine engines);`
    #[inline]
    pub unsafe fn GetEnginesByExtensionID(&self, extensionID: &::nsstring::nsAString, engineCount: *mut libc::uint32_t, engines: *mut *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetEnginesByExtensionID)(self, extensionID, engineCount, engines)
    }


    /// ```text
    /// /**
    ///    * Moves a visible search engine.
    ///    *
    ///    * @param  engine
    ///    *         The engine to move.
    ///    * @param  newIndex
    ///    *         The engine's new index in the set of visible engines.
    ///    *
    ///    * @throws NS_ERROR_FAILURE if newIndex is out of bounds, or if engine is
    ///    *         hidden.
    ///    */
    /// ```
    ///

    /// `void moveEngine (in nsISearchEngine engine, in long newIndex);`
    #[inline]
    pub unsafe fn MoveEngine(&self, engine: *const nsISearchEngine, newIndex: libc::int32_t) -> nsresult {
        ((*self.vtable).MoveEngine)(self, engine, newIndex)
    }


    /// ```text
    /// /**
    ///    * Removes the search engine. If the search engine is installed in a global
    ///    * location, this will just hide the engine. If the engine is in the user's
    ///    * profile directory, it will be removed from disk.
    ///    *
    ///    * @param  engine
    ///    *         The engine to remove.
    ///    */
    /// ```
    ///

    /// `void removeEngine (in nsISearchEngine engine);`
    #[inline]
    pub unsafe fn RemoveEngine(&self, engine: *const nsISearchEngine) -> nsresult {
        ((*self.vtable).RemoveEngine)(self, engine)
    }


    /// ```text
    /// /**
    ///    * The original Engine object that is the default for this region,
    ///    * ignoring changes the user may have subsequently made.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsISearchEngine originalDefaultEngine;`
    #[inline]
    pub unsafe fn GetOriginalDefaultEngine(&self, aOriginalDefaultEngine: *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetOriginalDefaultEngine)(self, aOriginalDefaultEngine)
    }


    /// ```text
    /// /**
    ///    * Alias for the currentEngine attribute, kept for add-on compatibility.
    ///    */
    /// ```
    ///

    /// `attribute nsISearchEngine defaultEngine;`
    #[inline]
    pub unsafe fn GetDefaultEngine(&self, aDefaultEngine: *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetDefaultEngine)(self, aDefaultEngine)
    }


    /// ```text
    /// /**
    ///    * Alias for the currentEngine attribute, kept for add-on compatibility.
    ///    */
    /// ```
    ///

    /// `attribute nsISearchEngine defaultEngine;`
    #[inline]
    pub unsafe fn SetDefaultEngine(&self, aDefaultEngine: *const nsISearchEngine) -> nsresult {
        ((*self.vtable).SetDefaultEngine)(self, aDefaultEngine)
    }


    /// ```text
    /// /**
    ///    * The currently active search engine.
    ///    * Unless the application doesn't ship any search plugin, this should never
    ///    * be null. If the currently active engine is removed, this attribute will
    ///    * fallback first to the original default engine if it's not hidden, then to
    ///    * the first visible engine, and as a last resort it will unhide the original
    ///    * default engine.
    ///    */
    /// ```
    ///

    /// `attribute nsISearchEngine currentEngine;`
    #[inline]
    pub unsafe fn GetCurrentEngine(&self, aCurrentEngine: *mut *const nsISearchEngine) -> nsresult {
        ((*self.vtable).GetCurrentEngine)(self, aCurrentEngine)
    }


    /// ```text
    /// /**
    ///    * The currently active search engine.
    ///    * Unless the application doesn't ship any search plugin, this should never
    ///    * be null. If the currently active engine is removed, this attribute will
    ///    * fallback first to the original default engine if it's not hidden, then to
    ///    * the first visible engine, and as a last resort it will unhide the original
    ///    * default engine.
    ///    */
    /// ```
    ///

    /// `attribute nsISearchEngine currentEngine;`
    #[inline]
    pub unsafe fn SetCurrentEngine(&self, aCurrentEngine: *const nsISearchEngine) -> nsresult {
        ((*self.vtable).SetCurrentEngine)(self, aCurrentEngine)
    }


    /// ```text
    /// /**
    ///    * Gets a representation of the default engine in an anonymized JSON
    ///    * string suitable for recording in the Telemetry environment.
    ///    *
    ///    * @return an object containing anonymized info about the default engine:
    ///    *         name, loadPath, submissionURL (for default engines).
    ///    */
    /// ```
    ///

    /// `jsval getDefaultEngineInfo ();`
    const _GetDefaultEngineInfo: () = ();

    /// ```text
    /// /**
    ///    * Determines if the provided URL represents results from a search engine, and
    ///    * provides details about the match.
    ///    *
    ///    * The lookup mechanism checks whether the domain name and path of the
    ///    * provided HTTP or HTTPS URL matches one of the known values for the visible
    ///    * search engines.  The match does not depend on which of the schemes is used.
    ///    * The expected URI parameter for the search terms must exist in the query
    ///    * string, but other parameters are ignored.
    ///    *
    ///    * @param url
    ///    *        String containing the URL to parse, for example
    ///    *        "https://www.google.com/search?q=terms".
    ///    */
    /// ```
    ///

    /// `nsISearchParseSubmissionResult parseSubmissionURL (in AString url);`
    #[inline]
    pub unsafe fn ParseSubmissionURL(&self, url: &::nsstring::nsAString, _retval: *mut *const nsISearchParseSubmissionResult) -> nsresult {
        ((*self.vtable).ParseSubmissionURL)(self, url, _retval)
    }


}