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


/// `interface nsIPaymentActionCallback : 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 nsIPaymentActionCallback {
    vtable: *const nsIPaymentActionCallbackVTable,

    /// 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 nsIPaymentActionCallback.
unsafe impl XpCom for nsIPaymentActionCallback {
    const IID: nsIID = nsID(0x3fef5459, 0xb0ea, 0x469b,
        [0xbe, 0x9f, 0xb9, 0x9e, 0x8c, 0xa7, 0x5d, 0x3d]);
}

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

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

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

    /* void respondPayment (in nsIPaymentActionResponse aResponse); */
    pub RespondPayment: unsafe extern "system" fn (this: *const nsIPaymentActionCallback, aResponse: *const nsIPaymentActionResponse) -> nsresult,

    /* void changeShippingAddress (in AString aRequestId, in nsIPaymentAddress aAddress); */
    pub ChangeShippingAddress: unsafe extern "system" fn (this: *const nsIPaymentActionCallback, aRequestId: &::nsstring::nsAString, aAddress: *const nsIPaymentAddress) -> nsresult,

    /* void changeShippingOption (in AString aRequestId, in AString aOption); */
    pub ChangeShippingOption: unsafe extern "system" fn (this: *const nsIPaymentActionCallback, aRequestId: &::nsstring::nsAString, aOption: &::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 nsIPaymentActionCallback {


    /// `void respondPayment (in nsIPaymentActionResponse aResponse);`
    #[inline]
    pub unsafe fn RespondPayment(&self, aResponse: *const nsIPaymentActionResponse) -> nsresult {
        ((*self.vtable).RespondPayment)(self, aResponse)
    }



    /// `void changeShippingAddress (in AString aRequestId, in nsIPaymentAddress aAddress);`
    #[inline]
    pub unsafe fn ChangeShippingAddress(&self, aRequestId: &::nsstring::nsAString, aAddress: *const nsIPaymentAddress) -> nsresult {
        ((*self.vtable).ChangeShippingAddress)(self, aRequestId, aAddress)
    }



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


}


/// `interface nsIPaymentActionRequest : 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 nsIPaymentActionRequest {
    vtable: *const nsIPaymentActionRequestVTable,

    /// 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 nsIPaymentActionRequest.
unsafe impl XpCom for nsIPaymentActionRequest {
    const IID: nsIID = nsID(0x7ddbe8be, 0xbeac, 0x4952,
        [0x96, 0xf6, 0x61, 0x99, 0x81, 0xdf, 0xf7, 0xa6]);
}

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

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

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

    /* readonly attribute AString requestId; */
    pub GetRequestId: unsafe extern "system" fn (this: *const nsIPaymentActionRequest, aRequestId: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute uint32_t type; */
    pub GetType: unsafe extern "system" fn (this: *const nsIPaymentActionRequest, aType: *mut uint32_t) -> nsresult,

    /* readonly attribute nsIPaymentActionCallback callback; */
    pub GetCallback: unsafe extern "system" fn (this: *const nsIPaymentActionRequest, aCallback: *mut *const nsIPaymentActionCallback) -> nsresult,

    /* void init (in AString aRequestId, in uint32_t aType, in nsIPaymentActionCallback aCallback); */
    pub Init: unsafe extern "system" fn (this: *const nsIPaymentActionRequest, aRequestId: &::nsstring::nsAString, aType: uint32_t, aCallback: *const nsIPaymentActionCallback) -> 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 nsIPaymentActionRequest {

    pub const UNKNOWN_ACTION: i64 = 0;


    pub const CREATE_ACTION: i64 = 1;


    pub const CANMAKE_ACTION: i64 = 2;


    pub const SHOW_ACTION: i64 = 3;


    pub const ABORT_ACTION: i64 = 4;


    pub const COMPLETE_ACTION: i64 = 5;


    pub const UPDATE_ACTION: i64 = 6;


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



    /// `readonly attribute uint32_t type;`
    #[inline]
    pub unsafe fn GetType(&self, aType: *mut uint32_t) -> nsresult {
        ((*self.vtable).GetType)(self, aType)
    }



    /// `readonly attribute nsIPaymentActionCallback callback;`
    #[inline]
    pub unsafe fn GetCallback(&self, aCallback: *mut *const nsIPaymentActionCallback) -> nsresult {
        ((*self.vtable).GetCallback)(self, aCallback)
    }



    /// `void init (in AString aRequestId, in uint32_t aType, in nsIPaymentActionCallback aCallback);`
    #[inline]
    pub unsafe fn Init(&self, aRequestId: &::nsstring::nsAString, aType: uint32_t, aCallback: *const nsIPaymentActionCallback) -> nsresult {
        ((*self.vtable).Init)(self, aRequestId, aType, aCallback)
    }


}


/// `interface nsIPaymentCreateActionRequest : nsIPaymentActionRequest`
///


// 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 nsIPaymentCreateActionRequest {
    vtable: *const nsIPaymentCreateActionRequestVTable,

    /// 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 nsIPaymentCreateActionRequest.
unsafe impl XpCom for nsIPaymentCreateActionRequest {
    const IID: nsIID = nsID(0x1d38dce6, 0x8bcd, 0x441b,
        [0xaa, 0x94, 0x68, 0xe3, 0x00, 0xb6, 0xe1, 0x75]);
}

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

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

impl nsIPaymentCreateActionRequest {
    /// Cast this `nsIPaymentCreateActionRequest` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIPaymentCreateActionRequestCoerce>(&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 nsIPaymentCreateActionRequest {
    type Target = nsIPaymentActionRequest;
    #[inline]
    fn deref(&self) -> &nsIPaymentActionRequest {
        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: nsIPaymentActionRequestCoerce> nsIPaymentCreateActionRequestCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIPaymentCreateActionRequest) -> &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 nsIPaymentCreateActionRequest
// 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 nsIPaymentCreateActionRequestVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIPaymentActionRequestVTable,

    /* readonly attribute uint64_t tabId; */
    pub GetTabId: unsafe extern "system" fn (this: *const nsIPaymentCreateActionRequest, aTabId: *mut uint64_t) -> nsresult,

    /* readonly attribute nsIPrincipal topLevelPrincipal; */
    pub GetTopLevelPrincipal: unsafe extern "system" fn (this: *const nsIPaymentCreateActionRequest, aTopLevelPrincipal: *mut *const nsIPrincipal) -> nsresult,

    /* readonly attribute nsIArray methodData; */
    pub GetMethodData: unsafe extern "system" fn (this: *const nsIPaymentCreateActionRequest, aMethodData: *mut *const nsIArray) -> nsresult,

    /* readonly attribute nsIPaymentDetails details; */
    pub GetDetails: unsafe extern "system" fn (this: *const nsIPaymentCreateActionRequest, aDetails: *mut *const nsIPaymentDetails) -> nsresult,

    /* readonly attribute nsIPaymentOptions options; */
    pub GetOptions: unsafe extern "system" fn (this: *const nsIPaymentCreateActionRequest, aOptions: *mut *const nsIPaymentOptions) -> nsresult,

    /* void initRequest (in AString aRequestId, in nsIPaymentActionCallback aCallback, in uint64_t aTabId, in nsIPrincipal aPrincipal, in nsIArray aMethodData, in nsIPaymentDetails aDetails, in nsIPaymentOptions aOptions); */
    pub InitRequest: unsafe extern "system" fn (this: *const nsIPaymentCreateActionRequest, aRequestId: &::nsstring::nsAString, aCallback: *const nsIPaymentActionCallback, aTabId: uint64_t, aPrincipal: *const nsIPrincipal, aMethodData: *const nsIArray, aDetails: *const nsIPaymentDetails, aOptions: *const nsIPaymentOptions) -> 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 nsIPaymentCreateActionRequest {


    /// `readonly attribute uint64_t tabId;`
    #[inline]
    pub unsafe fn GetTabId(&self, aTabId: *mut uint64_t) -> nsresult {
        ((*self.vtable).GetTabId)(self, aTabId)
    }



    /// `readonly attribute nsIPrincipal topLevelPrincipal;`
    #[inline]
    pub unsafe fn GetTopLevelPrincipal(&self, aTopLevelPrincipal: *mut *const nsIPrincipal) -> nsresult {
        ((*self.vtable).GetTopLevelPrincipal)(self, aTopLevelPrincipal)
    }



    /// `readonly attribute nsIArray methodData;`
    #[inline]
    pub unsafe fn GetMethodData(&self, aMethodData: *mut *const nsIArray) -> nsresult {
        ((*self.vtable).GetMethodData)(self, aMethodData)
    }



    /// `readonly attribute nsIPaymentDetails details;`
    #[inline]
    pub unsafe fn GetDetails(&self, aDetails: *mut *const nsIPaymentDetails) -> nsresult {
        ((*self.vtable).GetDetails)(self, aDetails)
    }



    /// `readonly attribute nsIPaymentOptions options;`
    #[inline]
    pub unsafe fn GetOptions(&self, aOptions: *mut *const nsIPaymentOptions) -> nsresult {
        ((*self.vtable).GetOptions)(self, aOptions)
    }



    /// `void initRequest (in AString aRequestId, in nsIPaymentActionCallback aCallback, in uint64_t aTabId, in nsIPrincipal aPrincipal, in nsIArray aMethodData, in nsIPaymentDetails aDetails, in nsIPaymentOptions aOptions);`
    #[inline]
    pub unsafe fn InitRequest(&self, aRequestId: &::nsstring::nsAString, aCallback: *const nsIPaymentActionCallback, aTabId: uint64_t, aPrincipal: *const nsIPrincipal, aMethodData: *const nsIArray, aDetails: *const nsIPaymentDetails, aOptions: *const nsIPaymentOptions) -> nsresult {
        ((*self.vtable).InitRequest)(self, aRequestId, aCallback, aTabId, aPrincipal, aMethodData, aDetails, aOptions)
    }


}


/// `interface nsIPaymentCompleteActionRequest : nsIPaymentActionRequest`
///


// 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 nsIPaymentCompleteActionRequest {
    vtable: *const nsIPaymentCompleteActionRequestVTable,

    /// 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 nsIPaymentCompleteActionRequest.
unsafe impl XpCom for nsIPaymentCompleteActionRequest {
    const IID: nsIID = nsID(0x4429697d, 0x1135, 0x47de,
        [0xa4, 0x6e, 0x51, 0x96, 0xd3, 0x99, 0xec, 0x55]);
}

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

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

impl nsIPaymentCompleteActionRequest {
    /// Cast this `nsIPaymentCompleteActionRequest` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIPaymentCompleteActionRequestCoerce>(&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 nsIPaymentCompleteActionRequest {
    type Target = nsIPaymentActionRequest;
    #[inline]
    fn deref(&self) -> &nsIPaymentActionRequest {
        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: nsIPaymentActionRequestCoerce> nsIPaymentCompleteActionRequestCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIPaymentCompleteActionRequest) -> &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 nsIPaymentCompleteActionRequest
// 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 nsIPaymentCompleteActionRequestVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIPaymentActionRequestVTable,

    /* readonly attribute AString completeStatus; */
    pub GetCompleteStatus: unsafe extern "system" fn (this: *const nsIPaymentCompleteActionRequest, aCompleteStatus: &mut ::nsstring::nsAString) -> nsresult,

    /* void initRequest (in AString aRequestId, in nsIPaymentActionCallback aCallback, in AString aCompleteStatus); */
    pub InitRequest: unsafe extern "system" fn (this: *const nsIPaymentCompleteActionRequest, aRequestId: &::nsstring::nsAString, aCallback: *const nsIPaymentActionCallback, aCompleteStatus: &::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 nsIPaymentCompleteActionRequest {


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



    /// `void initRequest (in AString aRequestId, in nsIPaymentActionCallback aCallback, in AString aCompleteStatus);`
    #[inline]
    pub unsafe fn InitRequest(&self, aRequestId: &::nsstring::nsAString, aCallback: *const nsIPaymentActionCallback, aCompleteStatus: &::nsstring::nsAString) -> nsresult {
        ((*self.vtable).InitRequest)(self, aRequestId, aCallback, aCompleteStatus)
    }


}


/// `interface nsIPaymentUpdateActionRequest : nsIPaymentActionRequest`
///


// 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 nsIPaymentUpdateActionRequest {
    vtable: *const nsIPaymentUpdateActionRequestVTable,

    /// 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 nsIPaymentUpdateActionRequest.
unsafe impl XpCom for nsIPaymentUpdateActionRequest {
    const IID: nsIID = nsID(0x21f631e8, 0xc047, 0x4fd8,
        [0xb3, 0xc6, 0x68, 0xe2, 0x6c, 0x62, 0x63, 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 nsIPaymentUpdateActionRequest {
    #[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 nsIPaymentUpdateActionRequest.
// 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 nsIPaymentUpdateActionRequestCoerce {
    /// Cheaply cast a value of this type from a `nsIPaymentUpdateActionRequest`.
    fn coerce_from(v: &nsIPaymentUpdateActionRequest) -> &Self;
}

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

impl nsIPaymentUpdateActionRequest {
    /// Cast this `nsIPaymentUpdateActionRequest` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIPaymentUpdateActionRequestCoerce>(&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 nsIPaymentUpdateActionRequest {
    type Target = nsIPaymentActionRequest;
    #[inline]
    fn deref(&self) -> &nsIPaymentActionRequest {
        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: nsIPaymentActionRequestCoerce> nsIPaymentUpdateActionRequestCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIPaymentUpdateActionRequest) -> &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 nsIPaymentUpdateActionRequest
// 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 nsIPaymentUpdateActionRequestVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsIPaymentActionRequestVTable,

    /* readonly attribute nsIPaymentDetails details; */
    pub GetDetails: unsafe extern "system" fn (this: *const nsIPaymentUpdateActionRequest, aDetails: *mut *const nsIPaymentDetails) -> nsresult,

    /* void initRequest (in AString aRequestId, in nsIPaymentActionCallback aCallback, in nsIPaymentDetails aDetails); */
    pub InitRequest: unsafe extern "system" fn (this: *const nsIPaymentUpdateActionRequest, aRequestId: &::nsstring::nsAString, aCallback: *const nsIPaymentActionCallback, aDetails: *const nsIPaymentDetails) -> 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 nsIPaymentUpdateActionRequest {


    /// `readonly attribute nsIPaymentDetails details;`
    #[inline]
    pub unsafe fn GetDetails(&self, aDetails: *mut *const nsIPaymentDetails) -> nsresult {
        ((*self.vtable).GetDetails)(self, aDetails)
    }



    /// `void initRequest (in AString aRequestId, in nsIPaymentActionCallback aCallback, in nsIPaymentDetails aDetails);`
    #[inline]
    pub unsafe fn InitRequest(&self, aRequestId: &::nsstring::nsAString, aCallback: *const nsIPaymentActionCallback, aDetails: *const nsIPaymentDetails) -> nsresult {
        ((*self.vtable).InitRequest)(self, aRequestId, aCallback, aDetails)
    }


}