/**@class android.content.pm.PackageParser.SigningDetails
 implements android.os.Parcelable

@extends java.lang.Object

  A container for signing-related data of an application package.
 @hide
*/
var SigningDetails = {

/***/
signatures : "null",
/***/
signatureSchemeVersion : "null",
/***/
publicKeys : "null",
/** APK Signature Scheme v3 includes support for adding a proof-of-rotation record that
 contains two pieces of information:
   1) the past signing certificates
   2) the flags that APK wants to assign to each of the past signing certificates.

 This collection of {@code Signature} objects, each of which is formed from a former
 signing certificate of this APK before it was changed by signing certificate rotation,
 represents the first piece of information.  It is the APK saying to the rest of the
 world: "hey if you trust the old cert, you can trust me!"  This is useful, if for
 instance, the platform would like to determine whether or not to allow this APK to do
 something it would've allowed it to do under the old cert (like upgrade).
*/
pastSigningCertificates : "null",
/**A representation of unknown signing details. Use instead of null. */
UNKNOWN : "null",
/***/
CREATOR : "null",
/**Returns true if the signing details have one or more signatures.
*/
hasSignatures : function(  ) {},

/**Returns true if the signing details have past signing certificates.
*/
hasPastSigningCertificates : function(  ) {},

/**Determines if the provided {@code oldDetails} is an ancestor of or the same as this one.
 If the {@code oldDetails} signing certificate appears in our pastSigningCertificates,
 then that means it has authorized a signing certificate rotation, which eventually leads
 to our certificate, and thus can be trusted. If this method evaluates to true, this
 SigningDetails object should be trusted if the previous one is.
*/
hasAncestorOrSelf : function(  ) {},

/**Similar to {@code hasAncestorOrSelf}.  Returns true only if this {@code SigningDetails}
 is a descendant of {@code oldDetails}, not if they're the same.  This is used to
 determine if this object is newer than the provided one.
*/
hasAncestor : function(  ) {},

/**Determines if the provided {@code oldDetails} is an ancestor of this one, and whether or
 not this one grants it the provided capability, represented by the {@code flags}
 parameter.  In the event of signing certificate rotation, a package may still interact
 with entities signed by its old signing certificate and not want to break previously
 functioning behavior.  The {@code flags} value determines which capabilities the app
 signed by the newer signing certificate would like to continue to give to its previous
 signing certificate(s).
*/
checkCapability : function(  ) {},

/**A special case of {@code checkCapability} which re-encodes both sets of signing
 certificates to counteract a previous re-encoding.
*/
checkCapabilityRecover : function(  ) {},

/**Determine if {@code signature} is in this SigningDetails' signing certificate history,
 including the current signer.  Automatically returns false if this object has multiple
 signing certificates, since rotation is only supported for single-signers; this is
 enforced by {@code hasCertificateInternal}.
*/
hasCertificate : function(  ) {},

/**Determine if {@code signature} is in this SigningDetails' signing certificate history,
 including the current signer, and whether or not it has the given permission.
 Certificates which match our current signer automatically get all capabilities.
 Automatically returns false if this object has multiple signing certificates, since
 rotation is only supported for single-signers.
*/
hasCertificate : function(  ) {},

/**Convenient wrapper for calling {@code hasCertificate} with certificate's raw bytes.
*/
hasCertificate : function(  ) {},

/**Determines if the provided {@code sha256String} is an ancestor of this one, and whether
 or not this one grants it the provided capability, represented by the {@code flags}
 parameter.  In the event of signing certificate rotation, a package may still interact
 with entities signed by its old signing certificate and not want to break previously
 functioning behavior.  The {@code flags} value determines which capabilities the app
 signed by the newer signing certificate would like to continue to give to its previous
 signing certificate(s).
@param {String} sha256String A hex-encoded representation of a sha256 digest.  In the case of an
                     app with multiple signers, this represents the hex-encoded sha256
                     digest of the combined hex-encoded sha256 digests of each individual
                     signing certificate according to {@link
                     PackageUtils#computeSignaturesSha256Digest(Signature[])}
*/
checkCapability : function(  ) {},

/**Determine if the {@code sha256Certificate} is in this SigningDetails' signing certificate
 history, including the current signer.  Automatically returns false if this object has
 multiple signing certificates, since rotation is only supported for single-signers.
*/
hasSha256Certificate : function(  ) {},

/**Determine if the {@code sha256Certificate} certificate hash corresponds to a signing
 certificate in this SigningDetails' signing certificate history, including the current
 signer, and whether or not it has the given permission.  Certificates which match our
 current signer automatically get all capabilities. Automatically returns false if this
 object has multiple signing certificates, since rotation is only supported for
 single-signers.
*/
hasSha256Certificate : function(  ) {},

/**Returns true if the signatures in this and other match exactly.
*/
signaturesMatchExactly : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**
*/
equals : function(  ) {},

/**
*/
hashCode : function(  ) {},


};