/** @const */
var forge = {};
forge.random = {};
/**
 * @param {number} count
 * @return {string}
 */
forge.random.getBytesSync = function(count){};

forge.util = {};
/** @constructor */
forge.util.ByteStringBuffer = function(){};
/**
 * @return {string}
 */
forge.util.ByteStringBuffer.prototype.getBytes = function(){};
/**
 * @param {string} value
 * @return {forge.util.ByteStringBuffer}
 */
forge.util.ByteStringBuffer.prototype.putBytes = function(value){};
/**
 * @param {number} i
 * @return {forge.util.ByteStringBuffer}
 */
forge.util.ByteStringBuffer.prototype.putInt16 = function(i){};
/**
 * @param {number} i
 * @return {forge.util.ByteStringBuffer}
 */
forge.util.ByteStringBuffer.prototype.putInt24Le = function(i){};
/**
 * @param {number} i
 * @return {forge.util.ByteStringBuffer}
 */
forge.util.ByteStringBuffer.prototype.putInt32Le = function(i){};
/**
 * @param {number} b
 * @param {number} n
 * @return {forge.util.ByteStringBuffer}
 */
forge.util.ByteStringBuffer.prototype.fillWithByte = function(b, n){};
/**
 * @param {number} count
 * @return {forge.util.ByteStringBuffer}
 */
forge.util.ByteStringBuffer.prototype.truncate = function(count){};
/**
 * @return {string}
 */
forge.util.ByteStringBuffer.prototype.toHex = function(){};
/** @type {string} */
forge.util.ByteStringBuffer.prototype.data;
/**
 * @param {string} input
 * @param {string=} encoding
 * @return {forge.util.ByteStringBuffer}
 */
forge.util.createBuffer = function(input, encoding){};
/**
 * @param {string} hex
 * @return {string}
 */
forge.util.hexToBytes = function(hex){};
/**
 * @param {string=} value
 * @return {string}
 */
forge.util.decodeUtf8 = function(value){};

/** @constructor */
forge.asn1 = function(){};
/**
 * @typedef
 * {{
 *    strict: (boolean|undefined),
 *    parseAllBytes: (boolean|undefined),
 *    decodeBitStrings: (boolean|undefined),
 * }}
 */
var DerOption;
/**
 * @param {forge.util.ByteStringBuffer|string} bytes
 * @param {DerOption=} options
 * @return {forge.asn1}
 */
forge.asn1.fromDer = function(bytes, options){};
/**
 * @param {forge.asn1} obj
 * @return {forge.util.ByteStringBuffer}
 */
forge.asn1.toDer = function(obj){};
/**
 * @param {number} num
 * @return {forge.util.ByteStringBuffer}
 */
forge.asn1.integerToDer = function(num){};
/**
 * @param {string} oid
 * @return {forge.util.ByteStringBuffer}
 */
forge.asn1.oidToDer = function(oid){};
forge.asn1.Type = {};
/** @type {number} */
forge.asn1.Type.UTF8;
/** @type {number} */
forge.asn1.Type.SET;
/** @type {number} */
forge.asn1.Type.SEQUENCE;
/** @type {number} */
forge.asn1.Type.BOOLEAN;
/** @type {number} */
forge.asn1.Type.INTEGER;
/** @type {number} */
forge.asn1.Type.OID;
/** @type {number} */
forge.asn1.Type.NULL;
/** @type {number} */
forge.asn1.Type.OCTETSTRING;
forge.asn1.Class = {};
/** @type {number} */
forge.asn1.Class.UNIVERSAL;
/** @type {number} */
forge.asn1.Class.CONTEXT_SPECIFIC;
/**
 * @param {number} tagClass
 * @param {number} type
 * @param {boolean} constructed
 * @param {Array<string>|string} value
 * @param {Object=} options
 * @return {forge.asn1}
 */
forge.asn1.create = function(tagClass, type, constructed, value, options){};
/** @type {Array<forge.asn1>} */
forge.asn1.prototype.value;

/** @constructor */
const forge_BigInteger = function(){};
/**
 * @param {forge_BigInteger} a
 * @return {number}
 */
forge_BigInteger.prototype.compareTo = function(a){};
/** @constructor */
const forge_cert = function(){};
/** @type {forge_key} */
forge_cert.prototype.publicKey;
/** @type {forge_cert_issuer} */
forge_cert.prototype.issuer;
/** @constructor */
const forge_key = function(){};
/** @type {forge_BigInteger} */
forge_key.prototype.n;
/** @type {forge_BigInteger} */
forge_key.prototype.e;
/** @constructor */
const forge_cert_issuer = function(){};
/** @type {Array<forge_cert_attr>} */
forge_cert_issuer.prototype.attributes;
/**
 * @typedef
 * {{
 *    valueTagClass: (number|undefined),
 *    type: (string|undefined),
 *    value: (string|undefined),
 * }}
 */
var forge_cert_attr;
/**
 * @typedef
 * {{
 *    key: (forge_key|undefined),
 *    certificate: (forge_cert|undefined),
 *    digestAlgorithm: (string|undefined),
 *    authenticatedAttributes: (Array<forge_cert_attr>|undefined),
 *    unauthenticatedAttributes: (Array<forge_cert_attr>|undefined),
 *    signature: (string|undefined),
 * }}
 */
var forge_signer;

/** @constructor */
forge.pkcs7 = function(){};
/**
 * @return {forge.pkcs7}
 */
forge.pkcs7.createSignedData = function(){};
/**
 * @return {forge.pkcs7}
 */
forge.pkcs7.createEnvelopedData = function(){};
/**
 * @param {forge_cert} cert
 */
forge.pkcs7.prototype.addCertificate = function(cert){};
/**
 * @param {forge_signer} signer
 */
forge.pkcs7.prototype.addSigner = function(signer){};
/** @type {Array<forge_signer>} */
forge.pkcs7.prototype.signers;
/** @type {Array<forge.asn1>} */
forge.pkcs7.prototype.signerInfos;
/**
 * @param {forge_cert} cert
 */
forge.pkcs7.prototype.addRecipient = function(cert){};
/** @type {forge.util.ByteStringBuffer} */
forge.pkcs7.prototype.content;
/**
 * @param {forge.util.ByteStringBuffer=} key
 * @param {string=} cipher
 */
forge.pkcs7.prototype.encrypt = function(key, cipher){};
/**
 * @typedef
 * {{
 *    detached: (boolean|undefined),
 * }}
 */
var forge_sign_option;
/**
 * @param {forge_sign_option} options
 */
forge.pkcs7.prototype.sign = function(options){};
/**
 * @return {forge.asn1}
 */
forge.pkcs7.prototype.toAsn1 = function(){};

/** @constructor */
forge.pkcs12 = function(){};
/**
 * @param {forge.asn1} obj
 * @param {boolean=} strict
 * @param {string=} password
 * @return {forge.pkcs12}
 */
forge.pkcs12.pkcs12FromAsn1 = function(obj, strict, password){};
/**
 * @typedef
 * {{
 *    localKeyId: (string|undefined),
 *    localKeyIdHex: (string|undefined),
 *    friendlyName: (string|undefined),
 *    bagType: (string|undefined),
 * }}
 */
var P12BagsFilter;
/**
 * @typedef
 * {{
 *    cert: forge_cert,
 *    key: forge_key,
 * }}
 */
var P12Bag;
/**
 * @param {P12BagsFilter} filter
 * @return {Object<string, Object<string|number, P12Bag>>}
 */
forge.pkcs12.prototype.getBags = function(filter){};

forge.oids = {};
/** @type {string} */
forge.oids.sha256;
forge.pki = {};
forge.pki.oids = {};
/** @type {string} */
forge.pki.oids.certBag;
/** @type {string} */
forge.pki.oids.pkcs8ShroudedKeyBag;
/** @type {string} */
forge.pki.oids.sha256;
/** @type {string} */
forge.pki.oids.contentType;
/** @type {string} */
forge.pki.oids.data;
/** @type {string} */
forge.pki.oids.messageDigest;
/** @type {string} */
forge.pki.oids.signingTime;
/**
 * @param {forge.asn1} obj
 * @param {boolean=} computeHash
 * @return {forge_cert}
 */
forge.pki.certificateFromAsn1 = function(obj, computeHash){};

forge.md = {};
/** @constructor */
forge.md.digest = function(){};
/**
 * @param {string=} msg
 * @param {string=} encoding
 * @return {forge.md.digest}
 */
forge.md.digest.prototype.update = function(msg, encoding){};
/**
 * @return {forge.util.ByteStringBuffer}
 */
forge.md.digest.prototype.digest = function(){};
forge.md.md5 = {};
forge.md.sha1 = {};
forge.md.sha256 = {};
/**
 * @return {forge.md.digest}
 */
forge.md.md5.create = function(){};
/**
 * @return {forge.md.digest}
 */
forge.md.sha1.create = function(){};
/**
 * @return {forge.md.digest}
 */
forge.md.sha256.create = function(){};

forge.cipher = {};
/** @constructor */
forge.cipher.BlockCipher = function(){};
/**
 * @typedef
 * {{
 *    iv: (string|undefined),
 *    additionalData: (string|undefined),
 *    tagLength: (number|undefined),
 *    tag: (string|undefined),
 *    output: (forge.util.ByteStringBuffer|undefined),
 * }}
 */
var CipherOptions;
/**
 * @param {CipherOptions} options
 */
forge.cipher.BlockCipher.prototype.start = function(options){};
/**
 * @param {forge.util.ByteStringBuffer} input
 */
forge.cipher.BlockCipher.prototype.update = function(input){};
/**
 * @return {boolean}
 */
forge.cipher.BlockCipher.prototype.finish = function(){};
/** @type {forge.util.ByteStringBuffer} */
forge.cipher.BlockCipher.prototype.output;
/**
 * @param {string} algorithm
 * @param {forge.util.ByteStringBuffer} key
 * @return {forge.cipher.BlockCipher}
 */
forge.cipher.createCipher = function(algorithm, key) {};