123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884
/** * Type definitions for OpenPGP.js http://openpgpjs.org/ * * Contributors: *  - FlowCrypt a. s. <https://flowcrypt.com> *  - Guillaume Lacasa <https://blog.lacasa.fr> *  - Errietta Kostala <https://github.com/errietta> */
import type { WebStream as GenericWebStream, NodeStream as GenericNodeStream } from '@openpgp/web-stream-tools';
/* ############## v5 KEY #################### */// The Key and PublicKey types can be used interchangably since TS cannot detect the difference, as they have the same class properties.// The declared readKey(s) return type is Key instead of a PublicKey since it seems more obvious that a Key can be cast to a PrivateKey.export function readKey(options: { armoredKey: string, config?: PartialConfig }): Promise<Key>;export function readKey(options: { binaryKey: Uint8Array, config?: PartialConfig }): Promise<Key>;export function readKeys(options: { armoredKeys: string, config?: PartialConfig }): Promise<Key[]>;export function readKeys(options: { binaryKeys: Uint8Array, config?: PartialConfig }): Promise<Key[]>;export function readPrivateKey(options: { armoredKey: string, config?: PartialConfig }): Promise<PrivateKey>;export function readPrivateKey(options: { binaryKey: Uint8Array, config?: PartialConfig }): Promise<PrivateKey>;export function readPrivateKeys(options: { armoredKeys: string, config?: PartialConfig }): Promise<PrivateKey[]>;export function readPrivateKeys(options: { binaryKeys: Uint8Array, config?: PartialConfig }): Promise<PrivateKey[]>;export function generateKey(options: KeyOptions & { format?: 'armored' }): Promise<SerializedKeyPair<string> & { revocationCertificate: string }>;export function generateKey(options: KeyOptions & { format: 'binary' }): Promise<SerializedKeyPair<Uint8Array> & { revocationCertificate: string }>;export function generateKey(options: KeyOptions & { format: 'object' }): Promise<KeyPair & { revocationCertificate: string }>;export function decryptKey(options: { privateKey: PrivateKey; passphrase?: MaybeArray<string>; config?: PartialConfig }): Promise<PrivateKey>;export function encryptKey(options: { privateKey: PrivateKey; passphrase?: MaybeArray<string>; config?: PartialConfig }): Promise<PrivateKey>;export function reformatKey(options: { privateKey: PrivateKey; userIDs?: MaybeArray<UserID>; passphrase?: string; keyExpirationTime?: number; date?: Date, format?: 'armored', config?: PartialConfig }): Promise<SerializedKeyPair<string> & { revocationCertificate: string }>;export function reformatKey(options: { privateKey: PrivateKey; userIDs?: MaybeArray<UserID>; passphrase?: string; keyExpirationTime?: number; date?: Date, format: 'binary', config?: PartialConfig }): Promise<SerializedKeyPair<Uint8Array> & { revocationCertificate: string }>;export function reformatKey(options: { privateKey: PrivateKey; userIDs?: MaybeArray<UserID>; passphrase?: string; keyExpirationTime?: number; date?: Date, format: 'object', config?: PartialConfig }): Promise<KeyPair & { revocationCertificate: string }>;export function revokeKey(options: { key: PrivateKey, reasonForRevocation?: ReasonForRevocation, date?: Date, format?: 'armored', config?: PartialConfig }): Promise<SerializedKeyPair<string>>;export function revokeKey(options: { key: PrivateKey, reasonForRevocation?: ReasonForRevocation, date?: Date, format: 'binary', config?: PartialConfig }): Promise<SerializedKeyPair<Uint8Array>>;export function revokeKey(options: { key: PrivateKey, reasonForRevocation?: ReasonForRevocation, date?: Date, format: 'object', config?: PartialConfig }): Promise<KeyPair>;export function revokeKey(options: { key: PrivateKey, revocationCertificate: string, date?: Date, format?: 'armored', config?: PartialConfig }): Promise<SerializedKeyPair<string>>;export function revokeKey(options: { key: PrivateKey, revocationCertificate: string, date?: Date, format: 'binary', config?: PartialConfig }): Promise<SerializedKeyPair<Uint8Array>>;export function revokeKey(options: { key: PrivateKey, revocationCertificate: string, date?: Date, format: 'object', config?: PartialConfig }): Promise<KeyPair>;export function revokeKey(options: { key: PublicKey, revocationCertificate: string, date?: Date, format?: 'armored', config?: PartialConfig }): Promise<{ publicKey: string, privateKey: null }>;export function revokeKey(options: { key: PublicKey, revocationCertificate: string, date?: Date, format: 'binary', config?: PartialConfig }): Promise<{ publicKey: Uint8Array, privateKey: null }>;export function revokeKey(options: { key: PublicKey, revocationCertificate: string, date?: Date, format: 'object', config?: PartialConfig }): Promise<{ publicKey: PublicKey, privateKey: null }>;
export abstract class Key {  public readonly keyPacket: PublicKeyPacket | SecretKeyPacket;  public subkeys: Subkey[]; // do not add/replace users directly  public users: User[]; // do not add/replace subkeys directly  public revocationSignatures: SignaturePacket[];  public write(): Uint8Array;  public armor(config?: Config): string;  public getExpirationTime(userID?: UserID, config?: Config): Promise<Date | typeof Infinity | null>;  public getKeyIDs(): KeyID[];  public getPrimaryUser(date?: Date, userID?: UserID, config?: Config): Promise<PrimaryUser>; // throws on error  public getUserIDs(): string[];  public isPrivate(): this is PrivateKey;  public toPublic(): PublicKey;  // NB: the order of the `update` declarations matters, since PublicKey includes PrivateKey  public update(sourceKey: PrivateKey, date?: Date, config?: Config): Promise<PrivateKey>;  public update(sourceKey: PublicKey, date?: Date, config?: Config): Promise<PublicKey>;  public signPrimaryUser(privateKeys: PrivateKey[], date?: Date, userID?: UserID, config?: Config): Promise<this>  public signAllUsers(privateKeys: PrivateKey[], date?: Date, config?: Config): Promise<this>  public verifyPrimaryKey(date?: Date, userID?: UserID, config?: Config): Promise<void>; // throws on error  public verifyPrimaryUser(publicKeys: PublicKey[], date?: Date, userIDs?: UserID, config?: Config): Promise<{ keyID: KeyID, valid: boolean | null }[]>;  public verifyAllUsers(publicKeys: PublicKey[], date?: Date, config?: Config): Promise<{ userID: string, keyID: KeyID, valid: boolean | null }[]>;  public isRevoked(signature?: SignaturePacket, key?: AnyKeyPacket, date?: Date, config?: Config): Promise<boolean>;  public getRevocationCertificate(date?: Date, config?: Config): Promise<MaybeStream<string> | undefined>;  public getEncryptionKey(keyID?: KeyID, date?: Date | null, userID?: UserID, config?: Config): Promise<this | Subkey>;  public getSigningKey(keyID?: KeyID, date?: Date | null, userID?: UserID, config?: Config): Promise<this | Subkey>;  public getKeys(keyID?: KeyID): (this | Subkey)[];  public getSubkeys(keyID?: KeyID): Subkey[];  public getFingerprint(): string;  public getCreationTime(): Date;  public getAlgorithmInfo(): AlgorithmInfo;  public getKeyID(): KeyID;  public toPacketList(): PacketList<AllowedKeyPackets>;}
type AllowedKeyPackets = PublicKeyPacket | PublicSubkeyPacket | SecretKeyPacket | SecretSubkeyPacket | UserIDPacket | UserAttributePacket | SignaturePacket;export class PublicKey extends Key {  constructor(packetlist: PacketList<AnyKeyPacket>);}
export class PrivateKey extends PublicKey {  constructor(packetlist: PacketList<AnyKeyPacket>);  public revoke(reason?: ReasonForRevocation, date?: Date, config?: Config): Promise<PrivateKey>;  public isDecrypted(): boolean;  public addSubkey(options: SubkeyOptions): Promise<PrivateKey>;  public getDecryptionKeys(keyID?: KeyID, date?: Date | null, userID?: UserID, config?: Config): Promise<PrivateKey | Subkey>  public update(sourceKey: PublicKey, date?: Date, config?: Config): Promise<PrivateKey>;}
export class Subkey {  constructor(subkeyPacket: SecretSubkeyPacket | PublicSubkeyPacket, mainKey: PublicKey);  public readonly keyPacket: SecretSubkeyPacket | PublicSubkeyPacket;  public readonly mainKey: PublicKey;  public bindingSignatures: SignaturePacket[];  public revocationSignatures: SignaturePacket[];  public verify(date?: Date, config?: Config): Promise<SignaturePacket>;  public isDecrypted(): boolean;  public getFingerprint(): string;  public getCreationTime(): Date;  public getAlgorithmInfo(): AlgorithmInfo;  public getKeyID(): KeyID;}
export interface User {  userID: UserIDPacket | null;  userAttribute: UserAttributePacket | null;  selfCertifications: SignaturePacket[];  otherCertifications: SignaturePacket[];  revocationSignatures: SignaturePacket[];}
export interface PrimaryUser {  index: number;  user: User;}
type AlgorithmInfo = {  algorithm: enums.publicKeyNames;  bits?: number;  curve?: EllipticCurveName;};
/* ############## v5 SIG #################### */
export function readSignature(options: { armoredSignature: string, config?: PartialConfig }): Promise<Signature>;export function readSignature(options: { binarySignature: Uint8Array, config?: PartialConfig }): Promise<Signature>;
export class Signature {  public readonly packets: PacketList<SignaturePacket>;  constructor(packetlist: PacketList<SignaturePacket>);  public write(): MaybeStream<Uint8Array>;  public armor(config?: Config): string;  public getSigningKeyIDs(): Array<KeyID>;}
interface VerificationResult {  keyID: KeyID;  verified: Promise<true>; // throws on invalid signature  signature: Promise<Signature>;}
/* ############## v5 CLEARTEXT #################### */
export function readCleartextMessage(options: { cleartextMessage: string, config?: PartialConfig }): Promise<CleartextMessage>;
export function createCleartextMessage(options: { text: string }): Promise<CleartextMessage>;
/** Class that represents an OpenPGP cleartext signed message. */export class CleartextMessage {  /** Returns ASCII armored text of cleartext signed message   */  armor(config?: Config): string;
  /** Returns the key IDs of the keys that signed the cleartext message   */  getSigningKeyIDs(): KeyID[];
  /** Get cleartext   */  getText(): string;
  /** Sign the cleartext message   *   *  @param privateKeys private keys with decrypted secret key data for signing   */  sign(privateKeys: PrivateKey[], signature?: Signature, signingKeyIDs?: KeyID[], date?: Date, userIDs?: UserID[], config?: Config): void;
  /** Verify signatures of cleartext signed message   *  @param keys array of keys to verify signatures   */  verify(keys: PublicKey[], date?: Date, config?: Config): Promise<VerificationResult[]>;}
/* ############## v5 MSG #################### */export function generateSessionKey(options: { encryptionKeys: MaybeArray<PublicKey>, date?: Date, encryptionUserIDs?: MaybeArray<UserID>, config?: PartialConfig }): Promise<SessionKey>;export function encryptSessionKey(options: EncryptSessionKeyOptions & { format?: 'armored' }): Promise<string>;export function encryptSessionKey(options: EncryptSessionKeyOptions & { format: 'binary' }): Promise<Uint8Array>;export function encryptSessionKey(options: EncryptSessionKeyOptions & { format: 'object' }): Promise<Message<Data>>;export function decryptSessionKeys<T extends MaybeStream<Data>>(options: { message: Message<T>, decryptionKeys?: MaybeArray<PrivateKey>, passwords?: MaybeArray<string>, date?: Date, config?: PartialConfig }): Promise<SessionKey[]>;
export function readMessage<T extends MaybeStream<string>>(options: { armoredMessage: T, config?: PartialConfig }): Promise<Message<T>>;export function readMessage<T extends MaybeStream<Uint8Array>>(options: { binaryMessage: T, config?: PartialConfig }): Promise<Message<T>>;
export function createMessage<T extends MaybeStream<string>>(options: { text: T, filename?: string, date?: Date, format?: enums.literalFormatNames }): Promise<Message<T>>;export function createMessage<T extends MaybeStream<Uint8Array>>(options: { binary: T, filename?: string, date?: Date, format?: enums.literalFormatNames }): Promise<Message<T>>;
export function encrypt<T extends MaybeStream<Data>>(options: EncryptOptions & { message: Message<T>, format?: 'armored' }): Promise<  T extends WebStream<infer X> ? WebStream<string> :  T extends NodeStream<infer X> ? NodeStream<string> :  string>;export function encrypt<T extends MaybeStream<Data>>(options: EncryptOptions & { message: Message<T>, format: 'binary' }): Promise<  T extends WebStream<infer X> ? WebStream<Uint8Array> :  T extends NodeStream<infer X> ? NodeStream<Uint8Array> :  Uint8Array>;export function encrypt<T extends MaybeStream<Data>>(options: EncryptOptions & { message: Message<T>, format: 'object' }): Promise<Message<T>>;
export function sign<T extends MaybeStream<Data>>(options: SignOptions & { message: Message<T>, format?: 'armored' }): Promise<  T extends WebStream<infer X> ? WebStream<string> :  T extends NodeStream<infer X> ? NodeStream<string> :  string>;export function sign<T extends MaybeStream<Data>>(options: SignOptions & { message: Message<T>, format: 'binary' }): Promise<  T extends WebStream<infer X> ? WebStream<Uint8Array> :  T extends NodeStream<infer X> ? NodeStream<Uint8Array> :  Uint8Array>;export function sign<T extends MaybeStream<Data>>(options: SignOptions & { message: Message<T>, format: 'object' }): Promise<Message<T>>;export function sign(options: SignOptions & { message: CleartextMessage, format?: 'armored' }): Promise<string>;export function sign(options: SignOptions & { message: CleartextMessage, format: 'object' }): Promise<CleartextMessage>;
export function decrypt<T extends MaybeStream<Data>>(options: DecryptOptions & { message: Message<T>, format: 'binary' }): Promise<DecryptMessageResult & {  data:  T extends WebStream<infer X> ? WebStream<Uint8Array> :  T extends NodeStream<infer X> ? NodeStream<Uint8Array> :  Uint8Array}>;export function decrypt<T extends MaybeStream<Data>>(options: DecryptOptions & { message: Message<T> }): Promise<DecryptMessageResult & {  data:  T extends WebStream<infer X> ? WebStream<string> :  T extends NodeStream<infer X> ? NodeStream<string> :  string}>;
export function verify<T extends MaybeStream<Data>>(options: VerifyOptions & { message: Message<T>, format: 'binary' }): Promise<VerifyMessageResult & {  data:  T extends WebStream<infer X> ? WebStream<Uint8Array> :  T extends NodeStream<infer X> ? NodeStream<Uint8Array> :  Uint8Array}>;export function verify<T extends MaybeStream<Data>>(options: VerifyOptions & { message: Message<T> }): Promise<VerifyMessageResult & {  data:  T extends WebStream<infer X> ? WebStream<string> :  T extends NodeStream<infer X> ? NodeStream<string> :  string}>;
/** Class that represents an OpenPGP message.  Can be an encrypted message, signed message, compressed message or literal message */export class Message<T extends MaybeStream<Data>> {
  public readonly packets: PacketList<AnyPacket>;  constructor(packetlist: PacketList<AnyPacket>);
  /** Returns binary representation of message   */  public write(): MaybeStream<Uint8Array>;
  /** Returns ASCII armored text of message   */  public armor(config?: Config): string;
  /** Decrypt the message      @param decryptionKeys array of private keys with decrypted secret data  */  public decrypt(decryptionKeys?: PrivateKey[], passwords?: string[], sessionKeys?: SessionKey[], date?: Date, config?: Config): Promise<Message<MaybeStream<Data>>>;
  /** Encrypt the message      @param encryptionKeys array of public keys, used to encrypt the message  */  public encrypt(encryptionKeys?: PublicKey[],  passwords?: string[], sessionKeys?: SessionKey[], wildcard?: boolean, encryptionKeyIDs?: KeyID[], date?: Date, userIDs?: UserID[], config?: Config): Promise<Message<MaybeStream<Data>>>;
  /** Returns the key IDs of the keys to which the session key is encrypted   */  public getEncryptionKeyIDs(): KeyID[];
  /** Get literal data that is the body of the message   */  public getLiteralData(): (T extends Stream<Data> ? WebStream<Uint8Array> : Uint8Array) | null;
  /** Returns the key IDs of the keys that signed the message   */  public getSigningKeyIDs(): KeyID[];
  /** Get literal data as text   */  public getText(): (T extends Stream<Data> ? WebStream<string> : string) | null;
  public getFilename(): string | null;
  /** Sign the message (the literal data packet of the message)      @param signingKeys private keys with decrypted secret key data for signing  */  public sign(signingKeys: PrivateKey[], signature?: Signature, signingKeyIDs?: KeyID[], date?: Date, userIDs?: UserID[], config?: Config): Promise<Message<T>>;
  /** Unwrap compressed message   */  public unwrapCompressed(): Message<T>;
  /** Verify message signatures      @param verificationKeys array of public keys to verify signatures  */  public verify(verificationKeys: PublicKey[], date?: Date, config?: Config): Promise<VerificationResult[]>;
  /**   * Append signature to unencrypted message object   * @param {String|Uint8Array} detachedSignature - The detached ASCII-armored or Uint8Array PGP signature   */  public appendSignature(detachedSignature: string | Uint8Array, config?: Config): Promise<void>;}

/* ############## v5 CONFIG #################### */
interface Config {  preferredHashAlgorithm: enums.hash;  preferredSymmetricAlgorithm: enums.symmetric;  preferredCompressionAlgorithm: enums.compression;  showVersion: boolean;  showComment: boolean;  deflateLevel: number;  aeadProtect: boolean;  allowUnauthenticatedMessages: boolean;  allowUnauthenticatedStream: boolean;  checksumRequired: boolean;  minRSABits: number;  passwordCollisionCheck: boolean;  revocationsExpire: boolean;  ignoreUnsupportedPackets: boolean;  ignoreMalformedPackets: boolean;  versionString: string;  commentString: string;  allowInsecureDecryptionWithSigningKeys: boolean;  constantTimePKCS1Decryption: boolean;  constantTimePKCS1DecryptionSupportedSymmetricAlgorithms: Set<enums.symmetric>;  v5Keys: boolean;  preferredAEADAlgorithm: enums.aead;  aeadChunkSizeByte: number;  s2kIterationCountByte: number;  minBytesForWebCrypto: number;  maxUserIDLength: number;  knownNotations: string[];  useIndutnyElliptic: boolean;  rejectHashAlgorithms: Set<enums.hash>;  rejectMessageHashAlgorithms: Set<enums.hash>;  rejectPublicKeyAlgorithms: Set<enums.publicKey>;  rejectCurves: Set<enums.curve>;}export var config: Config;
// PartialConfig has the same properties as Config, but declared as optional.// This interface is relevant for top-level functions, which accept a subset of configuration optionsinterface PartialConfig extends Partial<Config> {}
/* ############## v5 PACKET #################### */
declare abstract class BasePacket {  static readonly tag: enums.packet;  public read(bytes: Uint8Array): void;  public write(): Uint8Array;}
/** * The relationship between the KeyPacket classes is modeled by considering the following: * - A Secret (Sub)Key Packet can always be used when a Public one is expected. * - A Subkey Packet cannot always be used when a Primary Key Packet is expected (and vice versa). */declare abstract class BasePublicKeyPacket extends BasePacket {  public algorithm: enums.publicKey;  public created: Date;  public version: number;  public getAlgorithmInfo(): AlgorithmInfo;  public getFingerprint(): string;  public getFingerprintBytes(): Uint8Array | null;  public hasSameFingerprintAs(other: BasePublicKeyPacket): boolean;  public getCreationTime(): Date;  public getKeyID(): KeyID;  public isDecrypted(): boolean;  public publicParams: object;  // `isSubkey` is a dummy method to ensure that Subkey packets are not accepted as Key one, and vice versa.  // The key class hierarchy is already modelled to cover this, but the concrete key packet classes  // have compatible structure and TS can't detect the difference.  protected isSubkey(): boolean;}
export class PublicKeyPacket extends BasePublicKeyPacket {  static readonly tag: enums.packet.publicKey;  protected isSubkey(): false;}
export class PublicSubkeyPacket extends BasePublicKeyPacket {  static readonly tag: enums.packet.publicSubkey;  protected isSubkey(): true;}
declare abstract class BaseSecretKeyPacket extends BasePublicKeyPacket {  public privateParams: object | null;  public encrypt(passphrase: string, config?: Config): Promise<void>; // throws on error  public decrypt(passphrase: string): Promise<void>; // throws on error  public validate(): Promise<void>; // throws on error  public isDummy(): boolean;  public makeDummy(config?: Config): void;}
export class SecretKeyPacket extends BaseSecretKeyPacket {  static readonly tag: enums.packet.secretKey;  protected isSubkey(): false;}
export class SecretSubkeyPacket extends BaseSecretKeyPacket {  static readonly tag: enums.packet.secretSubkey;  protected isSubkey(): true;}
export class CompressedDataPacket extends BasePacket {  static readonly tag: enums.packet.compressedData;  private compress(): void;  private decompress(config?: Config): void;}
export class SymEncryptedIntegrityProtectedDataPacket extends BasePacket {  static readonly tag: enums.packet.symEncryptedIntegrityProtectedData;}
export class AEADEncryptedDataPacket extends BasePacket {  static readonly tag: enums.packet.aeadEncryptedData;  private decrypt(sessionKeyAlgorithm: enums.symmetric, sessionKey: Uint8Array, config?: Config): void;  private encrypt(sessionKeyAlgorithm: enums.symmetric, sessionKey: Uint8Array, config?: Config): void;  private crypt(fn: Function, sessionKey: Uint8Array, data: MaybeStream<Uint8Array>): MaybeStream<Uint8Array>}
export class PublicKeyEncryptedSessionKeyPacket extends BasePacket {  static readonly tag: enums.packet.publicKeyEncryptedSessionKey;  private decrypt(keyPacket: SecretKeyPacket): void; // throws on error  private encrypt(keyPacket: PublicKeyPacket): void; // throws on error}
export class SymEncryptedSessionKey extends BasePacket {  static readonly tag: enums.packet.symEncryptedSessionKey;  private decrypt(passphrase: string): Promise<void>;  private encrypt(passphrase: string, config?: Config): Promise<void>;}
export class LiteralDataPacket extends BasePacket {  static readonly tag: enums.packet.literalData;  private getText(clone?: boolean): MaybeStream<string>;  private getBytes(clone?: boolean): MaybeStream<Uint8Array>;  private setText(text: MaybeStream<string>, format?: enums.literal);  private setBytes(bytes: MaybeStream<Uint8Array>, format: enums.literal);  private setFilename(filename: string);  private getFilename(): string;  private writeHeader(): Uint8Array;}
export class SymmetricallyEncryptedDataPacket extends BasePacket {  static readonly tag: enums.packet.symmetricallyEncryptedData;  private decrypt(sessionKeyAlgorithm: enums.symmetric, sessionKey: Uint8Array, config?: Config): void;  private encrypt(sessionKeyAlgorithm: enums.symmetric, sessionKey: Uint8Array, config?: Config): void;}
export class MarkerPacket extends BasePacket {  static readonly tag: enums.packet.marker;}
export class UserAttributePacket extends BasePacket {  static readonly tag: enums.packet.userAttribute;  private equals(packet: UserAttributePacket): boolean;}
export class OnePassSignaturePacket extends BasePacket {  static readonly tag: enums.packet.onePassSignature;  public correspondingSig?: Promise<SignaturePacket>;  private verify: SignaturePacket['verify'];}
export class UserIDPacket extends BasePacket {  static readonly tag: enums.packet.userID;  public readonly name: string;  public readonly comment: string;  public readonly email: string;  public readonly userID: string;  static fromObject(userID: UserID): UserIDPacket;}
export class SignaturePacket extends BasePacket {  static readonly tag: enums.packet.signature;  public version: number;  public signatureType: enums.signature | null;  public hashAlgorithm: enums.hash | null;  public publicKeyAlgorithm: enums.publicKey | null;  public signatureData: null | Uint8Array;  public unhashedSubpackets: null | Uint8Array;  public signedHashValue: null | Uint8Array;  public created: Date | null;  public signatureExpirationTime: null | number;  public signatureNeverExpires: boolean;  public exportable: null | boolean;  public trustLevel: null | number;  public trustAmount: null | number;  public regularExpression: null | number;  public revocable: null | boolean;  public keyExpirationTime: null | number;  public keyNeverExpires: null | boolean;  public preferredSymmetricAlgorithms: enums.symmetric[] | null;  public revocationKeyClass: null | number;  public revocationKeyAlgorithm: null | enums.publicKey;  public revocationKeyFingerprint: null | Uint8Array;  public issuerKeyID: KeyID;  public notation: null | { [name: string]: string };  public preferredHashAlgorithms: enums.hash[] | null;  public preferredCompressionAlgorithms: enums.compression[] | null;  public keyServerPreferences: null | number[];  public preferredKeyServer: null | string;  public isPrimaryUserID: null | boolean;  public policyURI: null | string;  public keyFlags: Uint8Array | null;  public signersUserID: null | string;  public reasonForRevocationFlag: null | enums.reasonForRevocation;  public reasonForRevocationString: null | string;  public features: Uint8Array | null;  public signatureTargetPublicKeyAlgorithm: enums.publicKey | null;  public signatureTargetHashAlgorithm: enums.hash | null;  public signatureTargetHash: null | string;  public embeddedSignature: null | SignaturePacket;  public issuerKeyVersion: null | number;  public issuerFingerprint: null | Uint8Array;  public preferredAEADAlgorithms: enums.aead[] | null;  public revoked: null | boolean;  public sign(key: AnySecretKeyPacket, data: Uint8Array, date?: Date, detached?: boolean): Promise<void>;  public verify(key: AnyKeyPacket, signatureType: enums.signature, data: Uint8Array | object, date?: Date, detached?: boolean, config?: Config): Promise<void>; // throws on error  public isExpired(date?: Date): boolean;  public getExpirationTime(): Date | typeof Infinity;}
export class TrustPacket extends BasePacket {  static readonly tag: enums.packet.trust;}
export type AnyPacket = BasePacket;export type AnySecretKeyPacket = SecretKeyPacket | SecretSubkeyPacket;export type AnyKeyPacket = BasePublicKeyPacket;
type AllowedPackets = Map<enums.packet, object>; // mapping to Packet classes (i.e. typeof LiteralDataPacket etc.)export class PacketList<T extends AnyPacket> extends Array<T> {  static fromBinary(bytes: MaybeStream<Uint8Array>, allowedPackets: AllowedPackets, config?: Config): PacketList<AnyPacket>; // the packet types depend on`allowedPackets`  public read(bytes: MaybeStream<Uint8Array>, allowedPackets: AllowedPackets, config?: Config): void;  public write(): Uint8Array;  public filterByTag(...args: enums.packet[]): PacketList<T>;  public indexOfTag(...tags: enums.packet[]): number[];  public findPacket(tag: enums.packet): T | undefined;}
/* ############## v5 STREAM #################### */
type Data = Uint8Array | string;export interface WebStream<T extends Data> extends GenericWebStream<T> {}export interface NodeStream<T extends Data> extends GenericNodeStream<T> {}export type Stream<T extends Data> = WebStream<T> | NodeStream<T>;export type MaybeStream<T extends Data> = T | Stream<T>;
/* ############## v5 GENERAL #################### */type MaybeArray<T> = T | Array<T>;
export interface UserID { name?: string; email?: string; comment?: string; }export interface SessionKey {  data: Uint8Array;  algorithm: enums.symmetricNames;  aeadAlgorithm?: enums.aeadNames;}
export interface ReasonForRevocation { flag?: enums.reasonForRevocation, string?: string }
interface EncryptOptions {  /** message to be encrypted as created by createMessage */  message: Message<MaybeStream<Data>>;  /** (optional) array of keys or single key, used to encrypt the message */  encryptionKeys?: MaybeArray<PublicKey>;  /** (optional) private keys for signing. If omitted message will not be signed */  signingKeys?: MaybeArray<PrivateKey>;  /** (optional) array of passwords or a single password to encrypt the message */  passwords?: MaybeArray<string>;  /** (optional) session key */  sessionKey?: SessionKey;  /** if the return values should be ascii armored or the message/signature objects */  format?: 'armored' | 'binary' | 'object';  /** (optional) if the signature should be detached (if true, signature will be added to returned object) */  signature?: Signature;  /** (optional) encrypt as of a certain date */  date?: Date;  /** (optional) use a key ID of 0 instead of the public key IDs */  wildcard?: boolean;  /** (optional) Array of key IDs to use for signing. Each `signingKeyIDs[i]` corresponds to `signingKeys[i]` */  signingKeyIDs?: MaybeArray<KeyID>;  /** (optional) Array of key IDs to use for encryption. Each `encryptionKeyIDs[i]` corresponds to `encryptionKeys[i]`*/  encryptionKeyIDs?: MaybeArray<KeyID>;  /** (optional) Array of user IDs to sign with, e.g. { name:'Steve Sender', email:'steve@openpgp.org' } */  signingUserIDs?: MaybeArray<UserID>;  /** (optional) array of user IDs to encrypt for, e.g. { name:'Robert Receiver', email:'robert@openpgp.org' } */  encryptionUserIDs?: MaybeArray<UserID>;  config?: PartialConfig;}
interface DecryptOptions {  /** the message object with the encrypted data */  message: Message<MaybeStream<Data>>;  /** (optional) private keys with decrypted secret key data or session key */  decryptionKeys?: MaybeArray<PrivateKey>;  /** (optional) passwords to decrypt the message */  passwords?: MaybeArray<string>;  /** (optional) session keys in the form: { data:Uint8Array, algorithm:String } */  sessionKeys?: MaybeArray<SessionKey>;  /** (optional) array of public keys or single key, to verify signatures */  verificationKeys?: MaybeArray<PublicKey>;  /** (optional) whether data decryption should fail if the message is not signed with the provided publicKeys */  expectSigned?: boolean;  /** (optional) whether to return data as a string(Stream) or Uint8Array(Stream). If 'utf8' (the default), also normalize newlines. */  format?: 'utf8' | 'binary';  /** (optional) detached signature for verification */  signature?: Signature;  /** (optional) use the given date for verification instead of the current time */  date?: Date;  config?: PartialConfig;}
interface SignOptions {  message: CleartextMessage | Message<MaybeStream<Data>>;  signingKeys: MaybeArray<PrivateKey>;  format?: 'armored' | 'binary' | 'object';  detached?: boolean;  signingKeyIDs?: MaybeArray<KeyID>;  date?: Date;  signingUserIDs?: MaybeArray<UserID>;  config?: PartialConfig;}
interface VerifyOptions {  /** (cleartext) message object with signatures */  message: CleartextMessage | Message<MaybeStream<Data>>;  /** array of publicKeys or single key, to verify signatures */  verificationKeys: MaybeArray<PublicKey>;  /** (optional) whether verification should throw if the message is not signed with the provided publicKeys */  expectSigned?: boolean;  /** (optional) whether to return data as a string(Stream) or Uint8Array(Stream). If 'utf8' (the default), also normalize newlines. */  format?: 'utf8' | 'binary';  /** (optional) detached signature for verification */  signature?: Signature;  /** (optional) use the given date for verification instead of the current time */  date?: Date;  config?: PartialConfig;}
interface EncryptSessionKeyOptions extends SessionKey {  encryptionKeys?: MaybeArray<PublicKey>,  passwords?: MaybeArray<string>,  format?: 'armored' | 'binary' | 'object',  date?: Date,  wildcard?: boolean,  encryptionKeyIDs?: MaybeArray<KeyID>,  encryptionUserIDs?: MaybeArray<UserID>,  config?: PartialConfig}
interface SerializedKeyPair<T extends string|Uint8Array> {  privateKey: T;  publicKey: T;}interface KeyPair {  privateKey: PrivateKey;  publicKey: PublicKey;}
export type EllipticCurveName = 'ed25519' | 'curve25519' | 'p256' | 'p384' | 'p521' | 'secp256k1' | 'brainpoolP256r1' | 'brainpoolP384r1' | 'brainpoolP512r1';
interface KeyOptions {  userIDs: MaybeArray<UserID>;  passphrase?: string;  type?: 'ecc' | 'rsa';  curve?: EllipticCurveName;  rsaBits?: number;  keyExpirationTime?: number;  date?: Date;  subkeys?: SubkeyOptions[];  format?: 'armored' | 'object' | 'binary';  config?: PartialConfig;}
interface SubkeyOptions {  type?: 'ecc' | 'rsa';  curve?: EllipticCurveName;  rsaBits?: number;  keyExpirationTime?: number;  date?: Date;  sign?: boolean;  config?: PartialConfig;}
declare class KeyID {  bytes: string;  equals(keyID: KeyID, matchWildcard?: boolean): boolean;  toHex(): string;  static fromID(hex: string): KeyID;}
interface DecryptMessageResult {  data: MaybeStream<Data>;  signatures: VerificationResult[];  filename: string;}
interface VerifyMessageResult {  data: MaybeStream<Data>;  signatures: VerificationResult[];}

/** * Armor an OpenPGP binary packet block */export function armor(messagetype: enums.armor, body: object, partindex: number, parttotal: number, config?: Config): string;
/** * DeArmor an OpenPGP armored message; verify the checksum and return the encoded bytes */export function unarmor(input: string, config?: Config): Promise<{ text: string, data: Stream<Uint8Array>, type: enums.armor }>;
/* ############## v5 ENUMS #################### */
export namespace enums {  function read(type: typeof armor, e: armor): armorNames;  function read(type: typeof compression, e: compression): compressionNames;  function read(type: typeof hash, e: hash): hashNames;  function read(type: typeof packet, e: packet): packetNames;  function read(type: typeof publicKey, e: publicKey): publicKeyNames;  function read(type: typeof symmetric, e: symmetric): symmetricNames;  function read(type: typeof keyStatus, e: keyStatus): keyStatusNames;  function read(type: typeof keyFlags, e: keyFlags): keyFlagsNames;
  export type armorNames = 'multipartSection' | 'multipartLast' | 'signed' | 'message' | 'publicKey' | 'privateKey';  enum armor {    multipartSection = 0,    multipartLast = 1,    signed = 2,    message = 3,    publicKey = 4,    privateKey = 5,    signature = 6,  }
  enum reasonForRevocation {    noReason = 0, // No reason specified (key revocations or cert revocations)    keySuperseded = 1, // Key is superseded (key revocations)    keyCompromised = 2, // Key material has been compromised (key revocations)    keyRetired = 3, // Key is retired and no longer used (key revocations)    userIDInvalid = 32, // User ID information is no longer valid (cert revocations)  }
  export type compressionNames = 'uncompressed' | 'zip' | 'zlib' | 'bzip2';  enum compression {    uncompressed = 0,    zip = 1,    zlib = 2,    bzip2 = 3,  }
  export type hashNames = 'md5' | 'sha1' | 'ripemd' | 'sha256' | 'sha384' | 'sha512' | 'sha224';  enum hash {    md5 = 1,    sha1 = 2,    ripemd = 3,    sha256 = 8,    sha384 = 9,    sha512 = 10,    sha224 = 11,  }
  export type packetNames = 'publicKeyEncryptedSessionKey' | 'signature' | 'symEncryptedSessionKey' | 'onePassSignature' | 'secretKey' | 'publicKey'    | 'secretSubkey' | 'compressed' | 'symmetricallyEncrypted' | 'marker' | 'literal' | 'trust' | 'userID' | 'publicSubkey' | 'userAttribute'    | 'symEncryptedIntegrityProtected' | 'modificationDetectionCode' | 'AEADEncryptedDataPacket';  enum packet {    publicKeyEncryptedSessionKey = 1,    signature = 2,    symEncryptedSessionKey = 3,    onePassSignature = 4,    secretKey = 5,    publicKey = 6,    secretSubkey = 7,    compressedData = 8,    symmetricallyEncryptedData = 9,    marker = 10,    literalData = 11,    trust = 12,    userID = 13,    publicSubkey = 14,    userAttribute = 17,    symEncryptedIntegrityProtectedData = 18,    modificationDetectionCode = 19,    aeadEncryptedData = 20,  }
  export type publicKeyNames = 'rsaEncryptSign' | 'rsaEncrypt' | 'rsaSign' | 'elgamal' | 'dsa' | 'ecdh' | 'ecdsa' | 'eddsa' | 'aedh' | 'aedsa';  enum publicKey {    rsaEncryptSign = 1,    rsaEncrypt = 2,    rsaSign = 3,    elgamal = 16,    dsa = 17,    ecdh = 18,    ecdsa = 19,    eddsa = 22,    aedh = 23,    aedsa = 24,  }
  enum curve {    p256 = 'p256',    p384 = 'p384',    p521 = 'p521',    ed25519 = 'ed25519',    curve25519 = 'curve25519',    secp256k1 = 'secp256k1',    brainpoolP256r1 = 'brainpoolP256r1',    brainpoolP384r1 = 'brainpoolP384r1',    brainpoolP512r1 = 'brainpoolP512r1'  }
  export type symmetricNames = 'plaintext' | 'idea' | 'tripledes' | 'cast5' | 'blowfish' | 'aes128' | 'aes192' | 'aes256' | 'twofish';  enum symmetric {    plaintext = 0,    idea = 1,    tripledes = 2,    cast5 = 3,    blowfish = 4,    aes128 = 7,    aes192 = 8,    aes256 = 9,    twofish = 10,  }
  export type keyStatusNames = 'invalid' | 'expired' | 'revoked' | 'valid' | 'noSelfCert';  enum keyStatus {    invalid = 0,    expired = 1,    revoked = 2,    valid = 3,    noSelfCert = 4,  }
  export type keyFlagsNames = 'certifyKeys' | 'signData' | 'encryptCommunication' | 'encryptStorage' | 'splitPrivateKey' | 'authentication'    | 'sharedPrivateKey';  enum keyFlags {    certifyKeys = 1,    signData = 2,    encryptCommunication = 4,    encryptStorage = 8,    splitPrivateKey = 16,    authentication = 32,    sharedPrivateKey = 128,  }
  enum signature {    binary = 0,    text = 1,    standalone = 2,    certGeneric = 16,    certPersona = 17,    certCasual = 18,    certPositive = 19,    certRevocation = 48,    subkeyBinding = 24,    keyBinding = 25,    key = 31,    keyRevocation = 32,    subkeyRevocation = 40,    timestamp = 64,    thirdParty = 80  }
  export type aeadNames = 'eax' | 'ocb' | 'gcm';  enum aead {    eax = 1,    ocb = 2,    experimentalGCM = 100 // Private algorithm  }
  export type literalFormatNames = 'utf8' | 'binary' | 'text' | 'mime'  enum literal {    binary = 98,    text = 116,    utf8 = 117,    mime = 109  }}