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


/// `interface nsIX509Cert : nsISupports`
///

/// ```text
/// /**
///  * This represents a X.509 certificate.
///  *
///  * NOTE: Service workers persist x.509 certs in object form on disk.  If you
///  *       change this uuid you probably need a hack in nsBinaryInputStream to
///  *       read the old uuid.  If you change the format of the object
///  *       serialization then more complex changes will be needed.
///  */
/// ```
///

// 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 nsIX509Cert {
    vtable: *const nsIX509CertVTable,

    /// 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 nsIX509Cert.
unsafe impl XpCom for nsIX509Cert {
    const IID: nsIID = nsID(0xbdc3979a, 0x5422, 0x4cd5,
        [0x85, 0x89, 0x69, 0x6b, 0x6e, 0x96, 0xea, 0x83]);
}

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

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

impl nsIX509Cert {
    /// Cast this `nsIX509Cert` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIX509CertCoerce>(&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 nsIX509Cert {
    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> nsIX509CertCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIX509Cert) -> &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 nsIX509Cert
// 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 nsIX509CertVTable {
    /// 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 emailAddress; */
    pub GetEmailAddress: unsafe extern "system" fn (this: *const nsIX509Cert, aEmailAddress: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute bool isBuiltInRoot; */
    pub GetIsBuiltInRoot: unsafe extern "system" fn (this: *const nsIX509Cert, aIsBuiltInRoot: *mut bool) -> nsresult,

    /* [must_use] void getEmailAddresses (out unsigned long length, [array, size_is (length), retval] out wstring addresses); */
    pub GetEmailAddresses: unsafe extern "system" fn (this: *const nsIX509Cert, length: *mut libc::uint32_t, addresses: *mut *mut *const libc::int16_t) -> nsresult,

    /* [must_use] boolean containsEmailAddress (in AString aEmailAddress); */
    pub ContainsEmailAddress: unsafe extern "system" fn (this: *const nsIX509Cert, aEmailAddress: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* readonly attribute AString subjectName; */
    pub GetSubjectName: unsafe extern "system" fn (this: *const nsIX509Cert, aSubjectName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString commonName; */
    pub GetCommonName: unsafe extern "system" fn (this: *const nsIX509Cert, aCommonName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString organization; */
    pub GetOrganization: unsafe extern "system" fn (this: *const nsIX509Cert, aOrganization: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute AString organizationalUnit; */
    pub GetOrganizationalUnit: unsafe extern "system" fn (this: *const nsIX509Cert, aOrganizationalUnit: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString sha256Fingerprint; */
    pub GetSha256Fingerprint: unsafe extern "system" fn (this: *const nsIX509Cert, aSha256Fingerprint: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute AString sha1Fingerprint; */
    pub GetSha1Fingerprint: unsafe extern "system" fn (this: *const nsIX509Cert, aSha1Fingerprint: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString tokenName; */
    pub GetTokenName: unsafe extern "system" fn (this: *const nsIX509Cert, aTokenName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString issuerName; */
    pub GetIssuerName: unsafe extern "system" fn (this: *const nsIX509Cert, aIssuerName: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute AString serialNumber; */
    pub GetSerialNumber: unsafe extern "system" fn (this: *const nsIX509Cert, aSerialNumber: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute AString issuerCommonName; */
    pub GetIssuerCommonName: unsafe extern "system" fn (this: *const nsIX509Cert, aIssuerCommonName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute AString issuerOrganization; */
    pub GetIssuerOrganization: unsafe extern "system" fn (this: *const nsIX509Cert, aIssuerOrganization: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute AString issuerOrganizationUnit; */
    pub GetIssuerOrganizationUnit: unsafe extern "system" fn (this: *const nsIX509Cert, aIssuerOrganizationUnit: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute nsIX509Cert issuer; */
    pub GetIssuer: unsafe extern "system" fn (this: *const nsIX509Cert, aIssuer: *mut *const nsIX509Cert) -> nsresult,

    /* readonly attribute nsIX509CertValidity validity; */
    pub GetValidity: unsafe extern "system" fn (this: *const nsIX509Cert, aValidity: *mut *const nsIX509CertValidity) -> nsresult,

    /* [must_use] readonly attribute ACString dbKey; */
    pub GetDbKey: unsafe extern "system" fn (this: *const nsIX509Cert, aDbKey: &mut ::nsstring::nsACString) -> nsresult,

    /* [must_use] readonly attribute AString displayName; */
    pub GetDisplayName: unsafe extern "system" fn (this: *const nsIX509Cert, aDisplayName: &mut ::nsstring::nsAString) -> nsresult,

    /* readonly attribute unsigned long certType; */
    pub GetCertType: unsafe extern "system" fn (this: *const nsIX509Cert, aCertType: *mut libc::uint32_t) -> nsresult,

    /* [must_use] readonly attribute boolean isSelfSigned; */
    pub GetIsSelfSigned: unsafe extern "system" fn (this: *const nsIX509Cert, aIsSelfSigned: *mut bool) -> nsresult,

    /* [must_use] nsIArray getChain (); */
    pub GetChain: unsafe extern "system" fn (this: *const nsIX509Cert, _retval: *mut *const nsIArray) -> nsresult,

    /* [must_use] readonly attribute AString keyUsages; */
    pub GetKeyUsages: unsafe extern "system" fn (this: *const nsIX509Cert, aKeyUsages: &mut ::nsstring::nsAString) -> nsresult,

    /* [must_use] readonly attribute nsIASN1Object ASN1Structure; */
    pub GetASN1Structure: unsafe extern "system" fn (this: *const nsIX509Cert, aASN1Structure: *mut *const nsIASN1Object) -> nsresult,

    /* [must_use] void getRawDER (out unsigned long length, [array, size_is (length), retval] out octet data); */
    pub GetRawDER: unsafe extern "system" fn (this: *const nsIX509Cert, length: *mut libc::uint32_t, data: *mut *mut libc::uint8_t) -> nsresult,

    /* [must_use] boolean equals (in nsIX509Cert other); */
    pub Equals: unsafe extern "system" fn (this: *const nsIX509Cert, other: *const nsIX509Cert, _retval: *mut bool) -> nsresult,

    /* [must_use] readonly attribute ACString sha256SubjectPublicKeyInfoDigest; */
    pub GetSha256SubjectPublicKeyInfoDigest: unsafe extern "system" fn (this: *const nsIX509Cert, aSha256SubjectPublicKeyInfoDigest: &mut ::nsstring::nsACString) -> nsresult,

    /* [must_use] void exportAsCMS (in unsigned long chainMode, out unsigned long length, [array, size_is (length), retval] out octet data); */
    pub ExportAsCMS: unsafe extern "system" fn (this: *const nsIX509Cert, chainMode: libc::uint32_t, length: *mut libc::uint32_t, data: *mut *mut libc::uint8_t) -> nsresult,

    /* [must_use,noscript,notxpcom] CERTCertificatePtr getCert (); */
    /// Unable to generate binding because `native type CERTCertificate is unsupported`
    pub GetCert: *const ::libc::c_void,

    /* [must_use] void markForPermDeletion (); */
    pub MarkForPermDeletion: unsafe extern "system" fn (this: *const nsIX509Cert) -> 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 nsIX509Cert {
    /// ```text
    /// /**
    ///    *  Constants to classify the type of a certificate.
    ///    */
    /// ```
    ///

    pub const UNKNOWN_CERT: i64 = 0;


    pub const CA_CERT: i64 = 1;


    pub const USER_CERT: i64 = 2;


    pub const EMAIL_CERT: i64 = 4;


    pub const SERVER_CERT: i64 = 8;


    pub const ANY_CERT: i64 = 65535;

    /// ```text
    /// /**
    ///    *  Constants for specifying the chain mode when exporting a certificate
    ///    */
    /// ```
    ///

    pub const CMS_CHAIN_MODE_CertOnly: i64 = 1;


    pub const CMS_CHAIN_MODE_CertChain: i64 = 2;


    pub const CMS_CHAIN_MODE_CertChainWithRoot: i64 = 3;

    /// ```text
    /// /**
    ///    *  The primary email address of the certificate, if present.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Did this certificate ship with the platform as a built-in root?
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  Obtain a list of all email addresses
    ///    *  contained in the certificate.
    ///    *
    ///    *  @param length The number of strings in the returned array.
    ///    *  @return An array of email addresses.
    ///    */
    /// ```
    ///

    /// `[must_use] void getEmailAddresses (out unsigned long length, [array, size_is (length), retval] out wstring addresses);`
    #[inline]
    pub unsafe fn GetEmailAddresses(&self, length: *mut libc::uint32_t, addresses: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).GetEmailAddresses)(self, length, addresses)
    }


    /// ```text
    /// /**
    ///    *  Check whether a given address is contained in the certificate.
    ///    *  The comparison will convert the email address to lowercase.
    ///    *  The behaviour for non ASCII characters is undefined.
    ///    *
    ///    *  @param aEmailAddress The address to search for.
    ///    *
    ///    *  @return True if the address is contained in the certificate.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The subject owning the certificate.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The subject's common name.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The subject's organization.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The subject's organizational unit.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The fingerprint of the certificate's DER encoding,
    ///    *  calculated using the SHA-256 algorithm.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The fingerprint of the certificate's DER encoding,
    ///    *  calculated using the SHA1 algorithm.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  A human readable name identifying the hardware or
    ///    *  software token the certificate is stored on.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The subject identifying the issuer certificate.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The serial number the issuer assigned to this certificate.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The issuer subject's common name.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The issuer subject's organization.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The issuer subject's organizational unit.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  The certificate used by the issuer to sign this certificate.
    ///    */
    /// ```
    ///

    /// `[must_use] readonly attribute nsIX509Cert issuer;`
    #[inline]
    pub unsafe fn GetIssuer(&self, aIssuer: *mut *const nsIX509Cert) -> nsresult {
        ((*self.vtable).GetIssuer)(self, aIssuer)
    }


    /// ```text
    /// /**
    ///    *  This certificate's validity period.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIX509CertValidity validity;`
    #[inline]
    pub unsafe fn GetValidity(&self, aValidity: *mut *const nsIX509CertValidity) -> nsresult {
        ((*self.vtable).GetValidity)(self, aValidity)
    }


    /// ```text
    /// /**
    ///    *  A unique identifier of this certificate within the local storage.
    ///    */
    /// ```
    ///

    /// `[must_use] readonly attribute ACString dbKey;`
    #[inline]
    pub unsafe fn GetDbKey(&self, aDbKey: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetDbKey)(self, aDbKey)
    }


    /// ```text
    /// /**
    ///    *  A human readable identifier to label this certificate.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Type of this certificate
    ///    */
    /// ```
    ///

    /// `readonly attribute unsigned long certType;`
    #[inline]
    pub unsafe fn GetCertType(&self, aCertType: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).GetCertType)(self, aCertType)
    }


    /// ```text
    /// /**
    ///    *  True if the certificate is self-signed. CA issued
    ///    *  certificates are always self-signed.
    ///    */
    /// ```
    ///

    /// `[must_use] readonly attribute boolean isSelfSigned;`
    #[inline]
    pub unsafe fn GetIsSelfSigned(&self, aIsSelfSigned: *mut bool) -> nsresult {
        ((*self.vtable).GetIsSelfSigned)(self, aIsSelfSigned)
    }


    /// ```text
    /// /**
    ///    *  Obtain a list of certificates that contains this certificate
    ///    *  and the issuing certificates of all involved issuers,
    ///    *  up to the root issuer.
    ///    *
    ///    *  @return The chain of certifficates including the issuers.
    ///    */
    /// ```
    ///

    /// `[must_use] nsIArray getChain ();`
    #[inline]
    pub unsafe fn GetChain(&self, _retval: *mut *const nsIArray) -> nsresult {
        ((*self.vtable).GetChain)(self, _retval)
    }


    /// ```text
    /// /**
    ///    * A comma separated list of localized strings representing the contents of
    ///    * the certificate's key usage extension, if present. The empty string if the
    ///    * certificate doesn't have the key usage extension, or has an empty extension.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    *  This is the attribute which describes the ASN1 layout
    ///    *  of the certificate.  This can be used when doing a
    ///    *  "pretty print" of the certificate's ASN1 structure.
    ///    */
    /// ```
    ///

    /// `[must_use] readonly attribute nsIASN1Object ASN1Structure;`
    #[inline]
    pub unsafe fn GetASN1Structure(&self, aASN1Structure: *mut *const nsIASN1Object) -> nsresult {
        ((*self.vtable).GetASN1Structure)(self, aASN1Structure)
    }


    /// ```text
    /// /**
    ///    *  Obtain a raw binary encoding of this certificate
    ///    *  in DER format.
    ///    *
    ///    *  @param length The number of bytes in the binary encoding.
    ///    *  @param data The bytes representing the DER encoded certificate.
    ///    */
    /// ```
    ///

    /// `[must_use] void getRawDER (out unsigned long length, [array, size_is (length), retval] out octet data);`
    #[inline]
    pub unsafe fn GetRawDER(&self, length: *mut libc::uint32_t, data: *mut *mut libc::uint8_t) -> nsresult {
        ((*self.vtable).GetRawDER)(self, length, data)
    }


    /// ```text
    /// /**
    ///    *  Test whether two certificate instances represent the
    ///    *  same certificate.
    ///    *
    ///    *  @return Whether the certificates are equal
    ///    */
    /// ```
    ///

    /// `[must_use] boolean equals (in nsIX509Cert other);`
    #[inline]
    pub unsafe fn Equals(&self, other: *const nsIX509Cert, _retval: *mut bool) -> nsresult {
        ((*self.vtable).Equals)(self, other, _retval)
    }


    /// ```text
    /// /**
    ///    * The base64 encoding of the DER encoded public key info using the specified
    ///    * digest.
    ///    */
    /// ```
    ///

    /// `[must_use] readonly attribute ACString sha256SubjectPublicKeyInfoDigest;`
    #[inline]
    pub unsafe fn GetSha256SubjectPublicKeyInfoDigest(&self, aSha256SubjectPublicKeyInfoDigest: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).GetSha256SubjectPublicKeyInfoDigest)(self, aSha256SubjectPublicKeyInfoDigest)
    }


    /// ```text
    /// /**
    ///    *  Obtain the certificate wrapped in a PKCS#7 SignedData structure,
    ///    *  with or without the certificate chain
    ///    *
    ///    *  @param chainMode Whether to include the chain (with or without the root),
    ///                        see CMS_CHAIN_MODE constants.
    ///    *  @param length The number of bytes of the PKCS#7 data.
    ///    *  @param data The bytes representing the PKCS#7 wrapped certificate.
    ///    */
    /// ```
    ///

    /// `[must_use] void exportAsCMS (in unsigned long chainMode, out unsigned long length, [array, size_is (length), retval] out octet data);`
    #[inline]
    pub unsafe fn ExportAsCMS(&self, chainMode: libc::uint32_t, length: *mut libc::uint32_t, data: *mut *mut libc::uint8_t) -> nsresult {
        ((*self.vtable).ExportAsCMS)(self, chainMode, length, data)
    }


    /// ```text
    /// /**
    ///    * Retrieves the NSS certificate object wrapped by this interface
    ///    */
    /// ```
    ///

    /// `[must_use,noscript,notxpcom] CERTCertificatePtr getCert ();`
    const _GetCert: () = ();

    /// ```text
    /// /**
    ///    * Either delete the certificate from all cert databases,
    ///    * or mark it as untrusted.
    ///    */
    /// ```
    ///

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


}