/** Module: Utilities */ type Utilities = typeof Utilities; declare namespace Utilities { /** * Decodes a base-64 encoded string into a UTF-8 byte array. * * 

	 * // This is the base64 encoded form of "Google グループ"
	 * var base64data = "R29vZ2xlIOOCsOODq+ODvOODlw==";
	 * 
	 * // This logs:
	 * //     [71, 111, 111, 103, 108, 101, 32, -29, -126, -80,
	 * //      -29, -125, -85, -29, -125, -68, -29, -125, -105]
	 * var decoded = Utilities.base64Decode(base64data);
	 * Logger.log(decoded);
	 * 
	 * // If we want a String instead of a byte array:
	 * // This logs the original "Google グループ"
	 * Logger.log(Utilities.newBlob(decoded).getDataAsString());
	 *
* * @param encoded - an array of bytes of data to decode * * @returns the raw data represented by the base-64 encoded argument as a byte array */ function base64Decode( encoded: string ): number[] /** * Decodes a base-64 encoded string into a byte array in a specific character set. * * 

	 * // This is the base64 encoded form of "Google グループ"
	 * var base64data = "R29vZ2xlIOOCsOODq+ODvOODlw==";
	 * 
	 * var decoded = Utilities.base64Decode(base64data, Utilities.Charset.UTF_8);
	 * 
	 * // This logs:
	 * //     [71, 111, 111, 103, 108, 101, 32, -29, -126, -80,
	 * //      -29, -125, -85, -29, -125, -68, -29, -125, -105]
	 * Logger.log(decoded);
	 * 
	 * // If we want a String instead of a byte array:
	 * // This logs the original "Google グループ"
	 * Logger.log(Utilities.newBlob(decoded).getDataAsString());
	 *
* * @param encoded - the string of data to decode * @param charset - a Charset specifying the charset of the input * * @returns the raw data represented by the base-64 encoded argument as a byte array */ function base64Decode( encoded: string, charset: Utilities.Charset ): number[] /** * Decodes a base-64 web-safe encoded string into a UTF-8 byte array. * * 

	 * // This is the base64 web-safe encoded form of "Google グループ"
	 * var base64data = "R29vZ2xlIOOCsOODq-ODvOODlw==";
	 * 
	 * var decoded = Utilities.base64DecodeWebSafe(base64data);
	 * 
	 * // This logs:
	 * //     [71, 111, 111, 103, 108, 101, 32, -29, -126, -80,
	 * //      -29, -125, -85, -29, -125, -68, -29, -125, -105]
	 * Logger.log(decoded);
	 * 
	 * // If we want a String instead of a byte array:
	 * // This logs the original "Google グループ"
	 * Logger.log(Utilities.newBlob(decoded).getDataAsString());
	 *
* * @param encoded - an array of bytes of web-safe data to decode * * @returns the raw data represented by the base-64 web-safe encoded argument as a byte array */ function base64DecodeWebSafe( encoded: string ): number[] /** * Decodes a base-64 web-safe encoded string into a byte array in a specific character set. * * 

	 * // This is the base64 web-safe encoded form of "Google グループ"
	 * var base64data = "R29vZ2xlIOOCsOODq-ODvOODlw==";
	 * 
	 * var decoded = Utilities.base64DecodeWebSafe(base64data, Utilities.Charset.UTF_8);
	 * 
	 * // This logs:
	 * //     [71, 111, 111, 103, 108, 101, 32, -29, -126, -80,
	 * //      -29, -125, -85, -29, -125, -68, -29, -125, -105]
	 * Logger.log(decoded);
	 * 
	 * // If we want a String instead of a byte array:
	 * // This logs the original "Google グループ"
	 * Logger.log(Utilities.newBlob(decoded).getDataAsString());
	 *
* * @param encoded - the string of web-safe data to decode * @param charset - a Charset specifying the charset of the input * * @returns the raw data represented by the base-64 web-safe encoded argument as a byte array */ function base64DecodeWebSafe( encoded: string, charset: Utilities.Charset ): number[] /** * Generates a base-64 encoded string from the given byte array. Base 64 is a common encoding * accepted by a variety of tools that cannot accept binary data. Base 64 is commonly used in * internet protocols such as email, HTTP, or in XML documents. * * 

	 * // Instantiates a blob here for clarity
	 * var blob = Utilities.newBlob("A string here");
	 * 
	 * // Writes 'QSBzdHJpbmcgaGVyZQ==' to the log.
	 * var encoded = Utilities.base64Encode(blob.getBytes());
	 * Logger.log(encoded);
	 *
* * @param data - a byte[] of data to encode * * @returns the base-64 encoded representation of the passed in data */ function base64Encode( data: number[] ): string /** * Generates a base-64 encoded string from the given string. Base 64 is a common encoding accepted * by a variety of tools that cannot accept binary data. Base 64 is commonly used in internet * protocols such as email, HTTP, or in XML documents. * * 

	 * // Writes 'QSBzdHJpbmcgaGVyZQ==' to the log.
	 * var encoded = Utilities.base64Encode("A string here");
	 * Logger.log(encoded);
	 *
* * @param data - the string to encode * * @returns the base-64 encoded representation of the input string */ function base64Encode( data: string ): string /** * Generates a base-64 encoded string from the given string in a specific character set. A Charset * is a way of encoding characters such that they can be encoded. These are typically done in a * binary format, which can generally be incompatible with certain data transmission protocols. To * make the data compatible, they are generally encoded into base 64, which is a common encoding * accepted by a variety of tools that cannot accept binary data. Base 64 is commonly used in * internet protocols such as email, HTTP, or in XML documents. * * 

	 * // "Google Groups" in Katakana (Japanese)
	 * var input = "Google グループ";
	 * 
	 * // Writes "R29vZ2xlIOOCsOODq+ODvOODlw==" to the log
	 * var encoded = Utilities.base64Encode(input, Utilities.Charset.UTF_8);
	 * Logger.log(encoded);
	 * 
	 *
* * @param data - the string of data to encode * @param charset - a Charset specifying the charset of the input * * @returns the base-64 encoded representation of the input string with the given Charset */ function base64Encode( data: string, charset: Utilities.Charset ): string /** * Generates a base-64 web-safe encoded string from the given byte array. Base 64 is a common * encoding accepted by a variety of tools that cannot accept binary data. Base 64 web-safe is * commonly used in internet protocols such as email, HTTP, or in XML documents. * * 

	 * // Instantiates a blob here for clarity
	 * var blob = Utilities.newBlob("A string here");
	 * 
	 * // Writes 'QSBzdHJpbmcgaGVyZQ==' to the log.
	 * var encoded = Utilities.base64EncodeWebSafe(blob.getBytes());
	 * Logger.log(encoded);
	 *
* * @param data - an array of bytes of data to encode * * @returns the base-64 web-safe encoded representation of the passed in data */ function base64EncodeWebSafe( data: number[] ): string /** * Generates a base-64 web-safe encoded string from the given string. Base 64 is a common encoding * accepted by a variety of tools that cannot accept binary data. Base 64 web-safe is commonly * used in internet protocols such as email, HTTP, or in XML documents. * * 

	 * // Writes 'QSBzdHJpbmcgaGVyZQ==' to the log.
	 * var encoded = Utilities.base64EncodeWebSafe("A string here");
	 * Logger.log(encoded);
	 *
* * @param data - the string to encode * * @returns the base-64 web-safe encoded representation of the input string */ function base64EncodeWebSafe( data: string ): string /** * Generates a base-64 web-safe encoded string from the given string in a specific character set. * A Charset is a way of encoding characters such that they can be encoded. These are typically * done in a binary format, which can generally be incompatible with certain data transmission * protocols. To make the data compatible, they are generally encoded into base 64, which is a * common encoding accepted by a variety of tools that cannot accept binary data. Base 64 web-safe * is commonly used in internet protocols such as email, HTTP, or in XML documents. * * 

	 * // "Google Groups" in Katakana (Japanese)
	 * var input = "Google グループ";
	 * 
	 * // Writes "R29vZ2xlIOOCsOODq-ODvOODlw==" to the log
	 * var encoded = Utilities.base64EncodeWebSafe(input, Utilities.Charset.UTF_8);
	 * Logger.log(encoded);
	 * 
	 *
* * @param data - the string of data to encode * @param charset - a Charset specifying the charset of the input * * @returns the base-64 web-safe encoded representation of the input string with the given Charset */ function base64EncodeWebSafe( data: string, charset: Utilities.Charset ): string /** * Compute a digest using the specified algorithm on the specified Byte[] value. * * 

	 * var input = Utilities.base64Decode("aW5wdXQgdG8gaGFzaA0K") // == base64encode("input to hash")
	 * var digest = Utilities.computeDigest(Utilities.DigestAlgorithm.MD5, input);
	 * Logger.log(digest);
	 *
* * @param algorithm - a DigestAlgorithm to use * @param value - an input string value to compute a digest for * * @returns a byte[] representing the output digest */ function computeDigest( algorithm: DigestAlgorithm, value: number[] ): number[] /** * Compute a digest using the specified algorithm on the specified String value. * * 

	 * var digest = Utilities.computeDigest(Utilities.DigestAlgorithm.MD5, "input to hash");
	 * Logger.log(digest);
	 *
* * @param algorithm - a DigestAlgorithm to use * @param value - an input string value to compute a digest for * * @returns a byte[] representing the output digest */ function computeDigest( algorithm: DigestAlgorithm, value: string ): number[] /** * Compute a digest using the specified algorithm on the specified String value with the * given character set. * * 

	 * var digest = Utilities.computeDigest(Utilities.DigestAlgorithm.MD5,
	 *                                      "input to hash",
	 *                                      Utilities.Charset.US_ASCII);
	 * Logger.log(digest);
	 *
* * @param algorithm - a DigestAlgorithm to use * @param value - an input string value to compute a digest for * @param charset - a Charset representing the input character set * * @returns a byte[] representing the output digest */ function computeDigest( algorithm: DigestAlgorithm, value: string, charset: Utilities.Charset ): number[] /** * Signs the provided value using HMAC-SHA256 with the given key. * * 

	 * // This writes an array of bytes to the log.
	 * var input = Utilities.base64Decode("aW5wdXQgdG8gaGFzaA0K") // == base64encode("input to hash")
	 * var key = Utilities.base64Decode("a2V5"); // == base64encode("key")
	 * var signature = Utilities.computeHmacSha256Signature(input, key);
	 * Logger.log(signature);
	 *
* * @param value - the input value to generate a hash for * @param key - a key to use to generate the hash with * * @returns a byte[] representing the output signature */ function computeHmacSha256Signature( value: number[], key: number[] ): number[] /** * Signs the provided value using HMAC-SHA256 with the given key. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeHmacSha256Signature("this is my input",
	 *                                                       "my key - use a stronger one");
	 * Logger.log(signature);
	 *
* * @param value - the input value to generate a hash for * @param key - a key to use to generate the hash with * * @returns a byte[] representing the output signature */ function computeHmacSha256Signature( value: string, key: string ): number[] /** * Signs the provided value using HMAC-SHA256 with the given key and character set. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeHmacSha256Signature("this is my input",
	 *                                                      "my key - use a stronger one",
	 *                                                      Utilities.Charset.US_ASCII);
	 * Logger.log(signature);
	 *
* * @param value - the input value to generate a hash for * @param key - a key to use to generate the hash with * @param charset - a Charset representing the input character set * * @returns a byte[] representing the output signature */ function computeHmacSha256Signature( value: string, key: string, charset: Utilities.Charset ): number[] /** * Compute a message authentication code using the specified algorithm on the specified key and * value. * * 

	 * // This writes an array of bytes to the log.
	 * var input = Utilities.base64Decode("aW5wdXQgdG8gaGFzaA0K") // == base64encode("input to hash")
	 * var key = Utilities.base64Decode("a2V5"); // == base64encode("key")
	 * var signature = Utilities.computeHmacSignature(Utilities.MacAlgorithm.HMAC_MD5, input, key);
	 * Logger.log(signature);
	 *
* * @param algorithm - a MacAlgorithm algorithm to use to hash the input value * @param value - the input value to generate a hash for * @param key - a key to use to generate the hash with * * @returns a byte[] representing the output signature */ function computeHmacSignature( algorithm: Utilities.MacAlgorithm, value: number[], key: number[] ): number[] /** * Compute a message authentication code using the specified algorithm on the specified key and * value. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeHmacSignature(Utilities.MacAlgorithm.HMAC_MD5,
	 *                                                "input to hash",
	 *                                                "key");
	 * Logger.log(signature);
	 *
* * @param algorithm - a MacAlgorithm algorithm to use to hash the input value * @param value - the input value to generate a hash for * @param key - a key to use to generate the hash with * * @returns a byte[] representing the output signature */ function computeHmacSignature( algorithm: Utilities.MacAlgorithm, value: string, key: string ): number[] /** * Compute a message authentication code using the specified algorithm on the specified key and * value. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeHmacSignature(Utilities.MacAlgorithm.HMAC_MD5,
	 *                                                "input to hash",
	 *                                                "key",
	 *                                                Utilities.Charset.US_ASCII);
	 * Logger.log(signature);
	 *
* * @param algorithm - a MacAlgorithm algorithm to use to hash the input value * @param value - the input value to generate a hash for * @param key - a key to use to generate the hash with * @param charset - a Charset representing the input character set * * @returns a byte[] representing the output signature */ function computeHmacSignature( algorithm: Utilities.MacAlgorithm, value: string, key: string, charset: Utilities.Charset ): number[] /** * Signs the provided value using RSA-SHA1 with the given key. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeRsaSha1Signature("this is my input",
	 *     "-----BEGIN PRIVATE KEY-----\nprivatekeyhere\n-----END PRIVATE KEY-----\n");
	 * Logger.log(signature);
	 *
* * @param value - The input value to generate a hash for. * @param key - A PEM formatted key to use to generate the signature. * * @returns A byte[] representing the output signature. */ function computeRsaSha1Signature( value: string, key: string ): number[] /** * Signs the provided value using RSA-SHA1 with the given key and charset. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeRsaSha1Signature("this is my input",
	 *     "-----BEGIN PRIVATE KEY-----\nprivatekeyhere\n-----END PRIVATE KEY-----\n"
	 *     Utilities.Charset.US_ASCII);
	 * Logger.log(signature);
	 *
* * @param value - The input value to generate a hash for. * @param key - A PEM formatted key to use to generate the signature. * @param charset - A Charset representing the input character set. * * @returns A byte[] representing the output signature. */ function computeRsaSha1Signature( value: string, key: string, charset: Utilities.Charset ): number[] /** * Signs the provided value using RSA-SHA256 with the given key. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeRsaSha256Signature("this is my input",
	 *     "-----BEGIN PRIVATE KEY-----\nprivatekeyhere\n-----END PRIVATE KEY-----\n");
	 * Logger.log(signature);
	 *
* * @param value - the input value to generate a hash for * @param key - a PEM formatted key to use to generate the signature * * @returns a byte[] representing the output signature */ function computeRsaSha256Signature( value: string, key: string ): number[] /** * Signs the provided value using RSA-SHA256 with the given key. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeRsaSha256Signature("this is my input",
	 *     "-----BEGIN PRIVATE KEY-----\nprivatekeyhere\n-----END PRIVATE KEY-----\n");
	 * Logger.log(signature);
	 *
* * @param value - the input value to generate a hash for * @param key - a PEM formatted key to use to generate the signature * @param charset - a Charset representing the input character set * * @returns a byte[] representing the output signature */ function computeRsaSha256Signature( value: string, key: string, charset: Utilities.Charset ): number[] /** * Signs the provided value using the specified RSA algorithm with the given key. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeRsaSignature(Utilities.RsaAlgorithm.RSA_SHA_256,
	 *     "this is my input",
	 *     "-----BEGIN PRIVATE KEY-----\nprivatekeyhere\n-----END PRIVATE KEY-----\n");
	 * Logger.log(signature);
	 *
* * @param algorithm - A RsaAlgorithm algorithm to use to hash the input value. * @param value - The input value to generate a hash for. * @param key - A PEM formatted key to use to generate the signature. * * @returns A byte[] representing the output signature. */ function computeRsaSignature( algorithm: Utilities.RsaAlgorithm, value: string, key: string ): number[] /** * Signs the provided value using the specified RSA algorithm with the given key and charset. * * 

	 * // This writes an array of bytes to the log.
	 * var signature = Utilities.computeRsaSignature(Utilities.RsaAlgorithm.RSA_SHA_256,
	 *     "this is my input",
	 *     "-----BEGIN PRIVATE KEY-----\nprivatekeyhere\n-----END PRIVATE KEY-----\n",
	 *     Utilities.Charset.US_ASCII);
	 * Logger.log(signature);
	 *
* * @param algorithm - A RsaAlgorithm algorithm to use to hash the input value. * @param value - The input value to generate a hash for. * @param key - A PEM formatted key to use to generate the signature. * @param charset - A Charset representing the input character set. * * @returns A byte[] representing the output signature. */ function computeRsaSignature( algorithm: Utilities.RsaAlgorithm, value: string, key: string, charset: Utilities.Charset ): number[] /** * Formats date according to specification described in Java SE SimpleDateFormat class. Please * visit the specification at * http://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html * * 

	 * // This formats the date as Greenwich Mean Time in the format
	 * // year-month-dateThour-minute-second.
	 * var formattedDate = Utilities.formatDate(new Date(), "GMT", "yyyy-MM-dd'T'HH:mm:ss'Z'");
	 * Logger.log(formattedDate);
	 *
* * @param date - a Date to format as a String * @param timeZone - the output timezone of the result * @param format - a format per the SimpleDateFormat specification * * @returns the input date as a formatted string */ function formatDate( date: Date, timeZone: string, format: string ): string /** * Performs sprintf-like string formatting using '%'-style format strings. * * 

	 * // " 123.456000"
	 * Utilities.formatString('%11.6f', 123.456);
	 * 
	 * // "   abc"
	 * Utilities.formatString('%6s', 'abc');
	 *
* * @param template - The format string that controls what gets returned. * @param args - Objects to use to fill in the '%' placeholders in the template. * * @returns the formatted string. */ function formatString( template: string, ...args: Array ): string /** * Get a UUID as a string (equivalent to using the java.util.UUID.randomUUID() method). This identifier is not guaranteed to be unique across * all time and space. As such, do not use in situations where guaranteed uniqueness is required. * * 

	 * //This assigns a UUID as a temporary ID for a data object you are creating in your script.
	 * var myDataObject = {
	 *    tempId: Utilities.getUuid();
	 * };
	 *
* * @returns a string representation of the UUID */ function getUuid(): string /** * gzip-compresses the provided Blob data and returns it in a new Blob object. * * 

	 * var textBlob = Utilities.newBlob("Some text to compress using gzip compression");
	 * 
	 * // Create the compressed blob.
	 * var gzipBlob = Utilities.gzip(textBlob);
	 *
* * @param blob - a Blob object to compress using gzip. * * @returns a new Blob containing the compressed data. */ function gzip( blob: BlobSource ): Blob /** * gzip-compresses the provided Blob data and returns it in a new Blob object. This version of the method allows a filename to be specified. * * 

	 * var textBlob = Utilities.newBlob("Some text to compress using gzip compression");
	 * 
	 * // Create the compressed blob.
	 * var gzipBlob = Utilities.gzip(textBlob, "text.gz");
	 *
* * @param blob - a Blob object to compress using gzip. * @param name - the name of the gzip file to be created * * @returns a new Blob containing the compressed data. */ function gzip( blob: BlobSource, name: string ): Blob /** * Return an object corresponding to the JSON string passed in. * * 

	 * // Returns the object { name: "John Smith", company: "Virginia Company"}
	 * var obj = Utilities.jsonParse('{"name":"John Smith","company":"Virginia Company"}');
	 *
* * @param jsonString - a String representation of a JavaScript object to deserialize * * @returns a JavaScript object representation of the input */ function jsonParse( jsonString: string ): object /** * Return a JSON string of the object passed in. * * 

	 * // Logs: {"name":"John Smith","company":"Virginia Company"}
	 * var person = { name: "John Smith", company: "Virginia Company" };
	 * var json = Utilities.jsonStringify(person);
	 * Logger.log(json);
	 *
* * @param obj - the JavaScript object to serialize to JSON * * @returns a JSON serialized JavaScript object */ function jsonStringify( obj: object ): string /** * Create a new Blob object from a byte array. Blobs are used in many Apps Script APIs that take * binary data as input. * * @param data - the bytes for the blob * * @returns the newly created Blob */ function newBlob( data: number[] ): Blob /** * Create a new Blob object from a byte array and content type. Blobs are used in many Apps Script * APIs that take binary data as input. * * @param data - the bytes for the blob * @param contentType - the content type of the blob - can be null * * @returns the newly created Blob */ function newBlob( data: number[], contentType: string ): Blob /** * Create a new Blob object from a byte array, content type, and name. Blobs are used in many Apps * Script APIs that take binary data as input. * * @param data - the bytes for the blob * @param contentType - - the content type of the blob - can be null * @param name - the name of the blob - can be null * * @returns the newly created Blob */ function newBlob( data: number[], contentType: string, name: string ): Blob /** * Create a new Blob object from a string. Blobs are used in many Apps Script APIs that take * binary data as input. * * @param data - the string for the blob, assumed UTF-8 * * @returns the newly created Blob */ function newBlob( data: string ): Blob /** * Create a new Blob object from a string and content type. Blobs are used in many Apps Script * APIs that take binary data as input. * * @param data - the string for the blob, assumed UTF-8 * @param contentType - the content type of the blob - can be null * * @returns the newly created Blob */ function newBlob( data: string, contentType: string ): Blob /** * Create a new Blob object from a string, content type, and name. Blobs are used in many Apps * Script APIs that take binary data as input. * * @param data - the string for the blob, assumed UTF-8 * @param contentType - the content type of the blob - can be null * @param name - the name of the blob - can be null * * @returns the newly created Blob */ function newBlob( data: string, contentType: string, name: string ): Blob /** * Returns a tabular 2D array representation of a CSV string. * * 

	 * // This creates a two-dimensional array of the format [[a, b, c], [d, e, f]]
	 * var csvString = "a,b,c\nd,e,f";
	 * var data = Utilities.parseCsv(csvString);
	 *
* * @param csv - a string containing a single or multiline data in comma-separated value (CSV) format * * @returns a two-dimensional array containing the values in the CSV string */ function parseCsv( csv: string ): string[][] /** * Returns a tabular 2D array representation of a CSV string using a custom delimiter. * * 

	 * // This creates a two-dimensional array of the format [[a, b, c], [d, e, f]]
	 * var csvString = "a\tb\tc\nd\te\tf";
	 * var data = Utilities.parseCsv(csvString, '\t');
	 *
* * @param csv - a string containing a single or multiline data in comma-separated value (CSV) format * @param delimiter - between values * * @returns a two-dimensional array containing the values in the CSV string */ function parseCsv( csv: string, delimiter: string ): string[][] /** * Sleeps for specified number of milliseconds. Immediately puts the script to sleep for the * specified number of milliseconds. The maximum allowed value is 300000 (or 5 minutes). * * @param milliseconds - The number of milliseconds to sleep. */ function sleep( milliseconds: number ): void /** * Uncompresses a Blob object and returns a Blob containing the uncompressed * data. * * 

	 * var textBlob = Utilities.newBlob("Some text to compress using gzip compression");
	 * 
	 * // Create the compressed blob.
	 * var gzipBlob = Utilities.gzip(textBlob, "text.gz");
	 * 
	 * // Uncompress the data.
	 * var uncompressedBlob = Utilities.ungzip(gzipBlob);
	 *
* * @param blob - the Blob of compressed data. * * @returns a Blob representing the decompressed data. */ function ungzip( blob: BlobSource ): Blob /** * Takes a Blob representing a zip file and returns its component files. * * 

	 * var googleFavIconUrl = "https://www.google.com/favicon.ico";
	 * var googleLogoUrl = "https://www.google.com/images/srpr/logo3w.png";
	 * 
	 * // Fetch the Google favicon.ico file and get the Blob data
	 * var faviconBlob = UrlFetchApp.fetch(googleFavIconUrl).getBlob();
	 * var logoBlob = UrlFetchApp.fetch(googleLogoUrl).getBlob();
	 * 
	 * // zip now references a blob containing an archive of both faviconBlob and logoBlob
	 * var zip = Utilities.zip([faviconBlob, logoBlob], "google_images.zip");
	 * 
	 * // This now unzips the blobs
	 * var files = Utilities.unzip(zip);
	 *
* * @param blob - the zip file blob. * * @returns a Blob[] representing the component blobs, each named with the full path inside the zip */ function unzip( blob: BlobSource ): Blob[] /** * Creates a new Blob object that is a zip file containing the data from the Blobs passed in. * * 

	 * var googleFavIconUrl = "https://www.google.com/favicon.ico";
	 * var googleLogoUrl = "https://www.google.com/images/srpr/logo3w.png";
	 * 
	 * // Fetch the Google favicon.ico file and get the Blob data
	 * var faviconBlob = UrlFetchApp.fetch(googleFavIconUrl).getBlob();
	 * var logoBlob = UrlFetchApp.fetch(googleLogoUrl).getBlob();
	 * 
	 * // zip now references a blob containing an archive of both faviconBlob and logoBlob
	 * var zip = Utilities.zip([faviconBlob, logoBlob]);
	 *
* * @param blobs - a array of blobs to zip up * * @returns a new blob containing the inputs as an archive */ function zip( blobs: BlobSource[] ): Blob /** * Creates a new Blob object that is a zip file containing the data from the Blobs passed in. This * version of the method allows a filename to be specified. * * 

	 * var googleFavIconUrl = "https://www.google.com/favicon.ico";
	 * var googleLogoUrl = "https://www.google.com/images/srpr/logo3w.png";
	 * 
	 * // Fetch the Google favicon.ico file and get the Blob data
	 * var faviconBlob = UrlFetchApp.fetch(googleFavIconUrl).getBlob();
	 * var logoBlob = UrlFetchApp.fetch(googleLogoUrl).getBlob();
	 * 
	 * // zip now references a blob containing an archive of both faviconBlob and logoBlob
	 * var zip = Utilities.zip([faviconBlob, logoBlob], "google_images.zip");
	 *
* * @param blobs - a array of blobs to zip up * @param name - the name of the zip file to be created * * @returns a new blob containing the inputs as an archive */ function zip( blobs: BlobSource[], name: string ): Blob enum Charset { US_ASCII = "US_ASCII", UTF_8 = "UTF_8", } enum MacAlgorithm { HMAC_MD5 = "HMAC_MD5", HMAC_SHA_1 = "HMAC_SHA_1", HMAC_SHA_256 = "HMAC_SHA_256", HMAC_SHA_384 = "HMAC_SHA_384", HMAC_SHA_512 = "HMAC_SHA_512", } enum RsaAlgorithm { RSA_SHA_1 = "RSA_SHA_1", RSA_SHA_256 = "RSA_SHA_256", } }