/*
 * Copyright 2012 The Closure Compiler Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * @fileoverview Definitions for node's crypto module. Depends on the buffer module.
 * @see http://nodejs.org/api/crypto.html
 * @see https://github.com/joyent/node/blob/master/lib/crypto.js
 */

var stream = require('stream');

/**
 * @const
 */
var crypto = {};

/**
 * @type {string}
 */
crypto.DEFAULT_ENCODING;

/**
 * @constructor
 */
crypto.Credentials = function () {};

/** @type {string|Buffer} */
crypto.Credentials.prototype.pfx;

/** @type {string|Buffer} */
crypto.Credentials.prototype.key;

/** @type {string} */
crypto.Credentials.prototype.passphrase;

/** @type {string|Buffer} */
crypto.Credentials.prototype.cert;

/** @type {Array.<string|Buffer>} */
crypto.Credentials.prototype.ca;

/** @type {Array.<string>|string} */
crypto.Credentials.prototype.crl;

/** @type {string} */
crypto.Credentials.prototype.ciphers;

/**
 * @param {Object.<string,string>=} details
 * @return {crypto.Credentials}
 */
crypto.createCredentials;

/**
 * @param {string} algorithm
 * @return {crypto.Hash}
 */
crypto.createHash;

/**
 * @param {string} algorithm
 * @param {Object=} options
 * @constructor
 * @extends stream.Transform
 */
crypto.Hash = function(algorithm, options) {};

/**
 * @param {string|Buffer} data
 * @param {string=} input_encoding
 * @return {void}
 */
crypto.Hash.prototype.update;

/**
 * @param {string=} encoding
 * @return {string}
 */
crypto.Hash.prototype.digest;

/**
 * @param {string} algorithm
 * @param {string|Buffer} key
 * @return {crypto.Hmac}
 */
crypto.createHmac;

/**
 * @param {string} hmac
 * @param {string|Buffer} key
 * @param {Object=} options
 * @constructor
 * @extends stream.Transform
 */
crypto.Hmac = function(hmac, key, options) {};

/**
 * @param {string|Buffer} data
 * @return {void}
 */
crypto.Hmac.prototype.update;

/**
 * @param {string} encoding
 * @return {void}
 */
crypto.Hmac.prototype.digest;

/**
 * @param {string} algorithm
 * @param {string|Buffer} password
 * @return {crypto.Cipher}
 */
crypto.createCipher;

/**
 * @param {string} algorithm
 * @param {string|Buffer} key
 * @param {string|Buffer} iv
 * @return {crypto.Cipheriv}
 */
crypto.createCipheriv;

/**
 * @param {string|Buffer} cipher
 * @param {string} password
 * @param {Object=} options
 * @constructor
 * @extends stream.Transform
 */
crypto.Cipher = function(cipher, password, options) {};

/**
 * @param {string|Buffer} data
 * @param {string=} input_encoding
 * @param {string=} output_encoding
 * @return {string|Buffer}
 */
crypto.Cipher.prototype.update;

/**
 * @name crypto.Cipher.prototype.final
 * @param {string} output_encoding
 * @return {string|Buffer}
 */
crypto.Cipher.prototype.final;

/**
 * @param {boolean=} auto_padding
 * @return {void}
 */
crypto.Cipher.prototype.setAutoPadding;

/**
 * Note:  Cipheriv mixes update, final, and setAutoPadding from Cipher but
 * doesn't inherit directly from Cipher.
 *
 * @param {string} cipher
 * @param {string|Buffer} key
 * @param {string|Buffer} iv
 * @constructor
 * @extends stream.Transform
 */
crypto.Cipheriv = function(cipher, key, iv) {};

/**
 * @param {string|Buffer} data
 * @param {string=} input_encoding
 * @param {string=} output_encoding
 * @return {string|Buffer}
 */
crypto.Cipheriv.prototype.update;

/**
 * @name crypto.Cipheriv.prototype.final
 * @param {string} output_encoding
 * @return {string|Buffer}
 */
crypto.Cipheriv.prototype.final;

/**
 * @param {boolean=} auto_padding
 * @return {void}
 */
crypto.Cipheriv.prototype.setAutoPadding;

/**
 * @param {string} algorithm
 * @param {string|Buffer} password
 * @return {crypto.Decipher}
 */
crypto.createDecipher;

/**
 * @param {string} algorithm
 * @param {string|Buffer} key
 * @param {string|Buffer} iv
 * @return {crypto.Decipheriv}
 */
crypto.createDecipheriv;

/**
 * Note:  Decipher mixes update, final, and setAutoPadding from Cipher but
 * doesn't inherit directly from Cipher.
 *
 * @param {string|Buffer} cipher
 * @param {string|Buffer} password
 * @param {Object=} options
 * @constructor
 * @extends stream.Transform
 */
crypto.Decipher = function(cipher, password, options) {}

/**
 * @param {string|Buffer} data
 * @param {string=} input_encoding
 * @param {string=} output_encoding
 * @return {string|Buffer}
 */
crypto.Decipher.prototype.update;

/**
 * @name crypto.Decipher.prototype.final
 * @param {string} output_encoding
 * @return {string|Buffer}
 */
crypto.Decipher.prototype.final;

/**
 * @param {string} output_encoding
 * @return {string|Buffer}
 */
crypto.Decipher.prototype.finaltol;

/**
 * @param {boolean=} auto_padding
 * @return {void}
 */
crypto.Decipher.prototype.setAutoPadding;

/**
 * Note:  Decipheriv mixes update, final, and setAutoPadding from Cipher but
 * doesn't inherit directly from Cipher.
 *
 * @param {string|Buffer|crypto.Decipheriv} cipher
 * @param {string|Buffer} key
 * @param {string|Buffer} iv
 * @param {Object=} options
 * @constructor
 * @extends stream.Transform
 */
crypto.Decipheriv = function(cipher, key, iv, options) {};

/**
 * @param {string|Buffer} data
 * @param {string=} input_encoding
 * @param {string=} output_encoding
 * @return {string|Buffer}
 */
crypto.Decipheriv.prototype.update;

/**
 * @name crypto.Decipheriv.prototype.final
 * @param {string} output_encoding
 * @return {string|Buffer}
 */
crypto.Decipheriv.prototype.final;

/**
 * @param {string} output_encoding
 * @return {string|Buffer}
 */
crypto.Decipheriv.prototype.finaltol;

/**
 * @param {boolean=} auto_padding
 * @return {void}
 */
crypto.Decipheriv.prototype.setAutoPadding;

/**
 * @param {string} algorithm
 * @return {crypto.Sign}
 */
crypto.createSign;

/**
 * @param {string} algorithm
 * @param {Object=} options
 * @constructor
 * @extends stream.Writable
 */
crypto.Sign = function(algorithm, options) {};

/**
 * @param {string|Buffer} data
 * @return {void}
 */
crypto.Sign.prototype.update;

/**
 * @param {string} private_key
 * @param {string=} output_format
 * @return {string|Buffer}
 */
crypto.Sign.prototype.sign;

/**
 * @param {string} algorithm
 * @return crypto.Verify
 */
crypto.createVerify;

/**
 * @param {string} algorithm
 * @param {Object=} options
 * @constructor
 * @extends stream.Writable
 */
crypto.Verify = function(algorithm, options) {};

/**
 * @param {string|Buffer} data
 * @return {void}
 */
crypto.Verify.prototype.update;

/**
 * @param {string} object
 * @param {string|Buffer} signature
 * @param {string=} signature_format
 * @return {boolean}
 */
crypto.Verify.prototype.verify;

/**
 * @param {number} prime
 * @param {string=} encoding
 * @return {crypto.DiffieHellman}
 */
crypto.createDiffieHellman;

/**
 * @param {number} sizeOrKey
 * @param {string=} encoding
 * @constructor
 */
crypto.DiffieHellman = function(sizeOrKey, encoding) {};

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellman.prototype.generateKeys;

/**
 * @param {string|Buffer} key
 * @param {string=} inEnc
 * @param {string=} outEnc
 * @return {string|Buffer}
 */
crypto.DiffieHellman.prototype.computeSecret;

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellman.prototype.getPrime;

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellman.prototype.getGenerator;

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellman.prototype.getPublicKey;

/**
 * @param {string} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellman.prototype.getPrivateKey = function(encoding) {}

/**
 * @param {string|Buffer} key
 * @param {string=} encoding
 * @return {crypto.DiffieHellman}
 */
crypto.DiffieHellman.prototype.setPublicKey;

/**
 * @param {string|Buffer} key
 * @param {string=} encoding
 * @return {crypto.DiffieHellman}
 */
crypto.DiffieHellman.prototype.setPrivateKey;

/**
 * Note:  DiffieHellmanGroup mixes DiffieHellman but doesn't inherit directly.
 *
 * @param {string} name
 * @constructor
 */
crypto.DiffieHellmanGroup = function(name) {};

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellmanGroup.prototype.generateKeys;

/**
 * @param {string|Buffer} key
 * @param {string=} inEnc
 * @param {string=} outEnc
 * @return {string|Buffer}
 */
crypto.DiffieHellmanGroup.prototype.computeSecret;

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellmanGroup.prototype.getPrime;

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellmanGroup.prototype.getGenerator;

/**
 * @param {string=} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellmanGroup.prototype.getPublicKey;

/**
 * @param {string} encoding
 * @return {string|Buffer}
 */
crypto.DiffieHellmanGroup.prototype.getPrivateKey = function(encoding) {}

/**
 * @param {string|Buffer} key
 * @param {string=} encoding
 * @return {crypto.DiffieHellmanGroup}
 */
crypto.DiffieHellmanGroup.prototype.setPublicKey;

/**
 * @param {string|Buffer} key
 * @param {string=} encoding
 * @return {crypto.DiffieHellmanGroup}
 */
crypto.DiffieHellmanGroup.prototype.setPrivateKey;

/**
 * @param {string} group_name
 * @return {crypto.DiffieHellmanGroup}
 */
crypto.getDiffieHellman;

/**
 * @param {string|Buffer} password
 * @param {string|Buffer} salt
 * @param {number} iterations
 * @param {number} keylen
 * @param {function(*, string)} callback
 * @return {void}
 */
crypto.pbkdf2;

/**
 * @param {string|Buffer} password
 * @param {string|Buffer} salt
 * @param {number} iterations
 * @param {number} keylen
 * @return {void}
 */
crypto.pbkdf2Sync;

/**
 * @param {number} size
 * @param {function(Error, Buffer)=} callback
 * @return {void}
 */
crypto.randomBytes;

/**
 * @param {number} size
 * @param {function(Error, Buffer)=} callback
 * @return {void}
 */
crypto.pseudoRandomBytes;

/**
 * @param {number} size
 * @param {function(Error, Buffer)=} callback
 * @return {void}
 */
crypto.rng;

/**
 * @param {number} size
 * @param {function(Error, Buffer)=} callback
 * @return {void}
 */
crypto.prng;

/**
 * @return {Array.<string>}
 */
crypto.getCiphers;

/**
 * @return {Array.<string>}
 */
crypto.getHashes;

module.exports = crypto;
