gas-types-detailed
Version:
Enhanced Google Apps Script Type Definitions with detailed documentation. Includes type definitions plus code snippets, return values, required authorization scopes, and other details not found in @types/google-apps-script.
1,162 lines (1,106 loc) • 160 kB
TypeScript
// Type definitions for Google Apps Script 2025-11-10
// Project: https://developers.google.com/apps-script/
// Definitions by: motemen <https://github.com/motemen/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference path="google-apps-script.types.d.ts" />
/// <reference path="google-apps-script.base.d.ts" />
declare namespace GoogleAppsScript {
namespace Gmail {
/**
* Provides access to Gmail threads, messages, and labels.
*/
interface GmailApp {
/**
* Creates a draft email message. The size of the email (including headers) is quota limited.
*
* // The code below creates a draft email with the current date and time.
* const now = new Date();
* GmailApp.createDraft(
* 'mike@example.com',
* 'current time',
* `The time is: ${now.toString()}`,
* );
*
* Return:
* - GmailDraft — the newly created GmailDraft
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#createDraft(String,String,String)
* @param recipient comma separated list of email addresses
* @param subject subject of the email
* @param body body of the email
*/
createDraft(recipient: string, subject: string, body: string): GmailDraft;
/**
* Creates a draft email message with optional arguments. The email can contain plain text or an HTML body. The size of the email (including headers, but excluding attachments) is quota limited.
*
* // Create a draft email with a file from Google Drive attached as a PDF.
* const file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');
* GmailApp.createDraft(
* 'mike@example.com',
* 'Attachment example',
* 'Please see attached file.',
* {
* attachments: [file.getAs(MimeType.PDF)],
* name: 'Automatic Emailer Script',
* },
* );
*
* Return:
* - GmailDraft — the newly created GmailDraft
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#createDraft(String,String,String,Object)
* @param recipient the addresses of the recipient
* @param subject the subject line
* @param body the body of the email
* @param options a JavaScript object that specifies advanced parameters, as listed below
*
* Advanced parameters:
* - attachments (BlobSource[]) — an array of files to send with the email
* - bcc (String) — a comma-separated list of email addresses to BCC
* - cc (String) — a comma-separated list of email addresses to CC
* - from (String) — the address that the email should be sent from, which must be one of the values returned by getAliases()
* - htmlBody (String) — if set, devices capable of rendering HTML will use it instead of the required body argument; you can add an optional inlineImages field in HTML body if you have inlined images for your email
* - inlineImages (Object) — a JavaScript object containing a mapping from image key (String) to image data (BlobSource); this assumes that the htmlBody parameter is used and contains references to these images in the format <img src="cid:imageKey" />
* - name (String) — the name of the sender of the email (default: the user's name)
* - replyTo (String) — an email address to use as the default reply-to address (default: the user's email address)
*/
createDraft(recipient: string, subject: string, body: string, options: any): GmailDraft;
/**
* Create a new user label of the given name.
*
* // Creates the label @FOO and logs label: FOO
* Logger.log(`label: ${GmailApp.createLabel('FOO')}`);
*
* Return:
* - GmailLabel — the newly created label
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#createLabel(String)
* @param name the name of the new label
*/
createLabel(name: string): GmailLabel;
/**
* Deletes the specified label.
*
* // Have to get the label by name first
* const label = GmailApp.getUserLabelByName('FOO');
* GmailApp.deleteLabel(label);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#deleteLabel(GmailLabel)
* @param label the label to delete
*/
deleteLabel(label: GmailLabel): GmailApp;
/**
* Gets a list of the emails that are set up as aliases for this account in Gmail.
* You can send a message from any of these aliases by using the "from" optional argument.
*
* // Log the aliases for this Gmail account and send an email as the first one.
* const me = Session.getActiveUser().getEmail();
* const aliases = GmailApp.getAliases();
* Logger.log(aliases);
* if (aliases.length > 0) {
* GmailApp.sendEmail(me, 'From an alias', 'A message from an alias!', {
* from: aliases[0],
* });
* } else {
* GmailApp.sendEmail(me, 'No aliases found', 'You have no aliases.');
* }
*
* Return:
* - String[] — an array of aliases for this account
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getAliases()
*/
getAliases(): string[];
/**
* Retrieve an email message draft by ID.
* Use this in conjunction with getId() on Gmail drafts.
*
* // Get the first draft message in your drafts folder
* const draft = GmailApp.getDrafts()[0];
* // Get its ID
* const draftId = draft.getId();
* // Now fetch the same draft using that ID.
* const draftById = GmailApp.getDraft(draftId);
* // Should always log true as they should be the same message
* Logger.log(
* draft.getMessage().getSubject() === draftById.getMessage().getSubject(),
* );
*
* Return:
* - GmailDraft — the draft with the given ID
*
* Throws:
* - Error — if no draft with the given ID can be found
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getDraft(String)
* @param draftId the ID of the draft to retrieve
*/
getDraft(draftId: string): GmailDraft;
/**
* Retrieves all draft messages.
*
* // Logs the number of draft messages
* const drafts = GmailApp.getDraftMessages();
* Logger.log(drafts.length);
*
* Return:
* - GmailMessage[] — an array of draft Gmail messages
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getDraftMessages()
*/
getDraftMessages(): GmailMessage[];
/**
* Gets all Gmail draft messages.
*
* const drafts = GmailApp.getDrafts();
* for (let i = 0; i < drafts.length; i++) {
* Logger.log(drafts[i].getId());
* }
*
* Return:
* - GmailDraft[] — an array of Gmail draft messages
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getDrafts()
*/
getDrafts(): GmailDraft[];
/**
* Retrieves all Inbox threads irrespective of labels.
* This call will fail when the size of all threads is too large for the system to handle. Where the thread size is unknown, and potentially very large, please use the 'paged' call, and specify ranges of the threads to retrieve in each call.
*
* // Log the subject lines of your Inbox
* const threads = GmailApp.getInboxThreads();
* for (let i = 0; i < threads.length; i++) {
* Logger.log(threads[i].getFirstMessageSubject());
* }
*
* Return:
* - GmailThread[] — an array of Gmail threads in the Inbox
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getInboxThreads()
*/
getInboxThreads(): GmailThread[];
/**
* Retrieves a range of Inbox threads irrespective of labels.
*
* // Log the subject lines of up to the first 50 emails in your Inbox
* const threads = GmailApp.getInboxThreads(0, 50);
* for (let i = 0; i < threads.length; i++) {
* Logger.log(threads[i].getFirstMessageSubject());
* }
*
* Return:
* - GmailThread[] — an array of Gmail threads in the Inbox
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getInboxThreads(Integer,Integer)
* @param start the index of the first thread to retrieve
* @param max the maximum number of threads to retrieve
*/
getInboxThreads(start: Integer, max: Integer): GmailThread[];
/**
* Gets the number of unread threads in the inbox.
*
* Logger.log(`Messages unread in inbox: ${GmailApp.getInboxUnreadCount()}`);
*
* Return:
* - Integer — the number of threads in the inbox that have unread messages
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getInboxUnreadCount()
*/
getInboxUnreadCount(): Integer;
/**
* Gets a message by ID.
* Use this in conjunction with getId() on Gmail messages.
*
* // Get the first message in the first thread of your inbox
* const message = GmailApp.getInboxThreads(0, 1)[0].getMessages()[0];
* // Get its ID
* const messageId = message.getId();
* // Now fetch the same message using that ID.
* const messageById = GmailApp.getMessageById(messageId);
* // Should always log true as they should be the same message
* Logger.log(message.getSubject() === messageById.getSubject());
*
* Return:
* - GmailMessage — the message with the given ID
*
* Throws:
* - Error — if no message with the given ID can be found
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getMessageById(String)
* @param id the ID of the message to retrieve
*/
getMessageById(id: string): GmailMessage;
/**
* Retrieve all messages in the specified thread.
*
* // Log all the subject lines in the first thread of your inbox
* const thread = GmailApp.getInboxThreads(0, 1)[0];
* const messages = GmailApp.getMessagesForThread(thread);
* for (let i = 0; i < messages.length; i++) {
* Logger.log(`subject: ${messages[i].getSubject()}`);
* }
*
* Return:
* - GmailMessage[] — array of messages corresponding to this thread
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getMessagesForThread(GmailThread)
* @param thread the thread of messages to retrieve
*/
getMessagesForThread(thread: GmailThread): GmailMessage[];
/**
* Retrieve all messages in the specified threads.
*
* // Log the subject lines of all messages in the first two threads of your inbox
* const thread = GmailApp.getInboxThreads(0, 2);
* const messages = GmailApp.getMessagesForThreads(thread);
* for (let i = 0; i < messages.length; i++) {
* for (let j = 0; j < messages[i].length; j++) {
* Logger.log(`subject: ${messages[i][j].getSubject()}`);
* }
* }
*
* Return:
* - GmailMessage[][] — an array of arrays of messages, where each item in the outer array corresponds to a thread and the inner array contains the messages in that thread
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getMessagesForThreads(GmailThread)
* @param threads the threads of messages to retrieve
*/
getMessagesForThreads(threads: GmailThread[]): any[];
/**
* Retrieves all Priority Inbox threads irrespective of labels.
* This call will fail when the size of all threads is too large for the system to handle. Where the thread size is unknown, and potentially very large, please use the 'paged' call, and specify ranges of the threads to retrieve in each call.
*
* Logger.log(
* `# of messages in your Priority Inbox: ${
* GmailApp.getPriorityInboxThreads().length}`,
* );
*
* Return:
* - GmailThread[] — an array of Gmail threads in the Priority Inbox
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getPriorityInboxThreads()
*/
getPriorityInboxThreads(): GmailThread[];
/**
* Retrieves a range of Priority Inbox threads irrespective of labels.
*
* // Will log some number 2 or less
* Logger.log(
* `# of messages in your Priority Inbox: ${
* GmailApp.getPriorityInboxThreads(0, 2).length}`,
* );
*
* Return:
* - GmailThread[] — an array of Gmail threads in the Priority Inbox
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getPriorityInboxThreads(Integer,Integer)
* @param start the index of the first thread to retrieve
* @param max the maximum number of threads to retrieve
*/
getPriorityInboxThreads(start: Integer, max: Integer): GmailThread[];
/**
* Gets the number of unread threads in the Priority Inbox.
*
* Logger.log(
* `Number of unread emails in your Priority Inbox : ${
* GmailApp.getPriorityInboxUnreadCount()}`,
* );
*
* Return:
* - Integer — the number of threads in the Priority Inbox that have unread messages
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getPriorityInboxUnreadCount()
*/
getPriorityInboxUnreadCount(): Integer;
/**
* Retrieves all spam threads irrespective of labels.
* This call will fail when the size of all threads is too large for the system to handle. Where the thread size is unknown, and potentially very large, please use the 'paged' call, and specify ranges of the threads to retrieve in each call.
*
* Logger.log(`# of total spam threads: ${GmailApp.getSpamThreads().length}`);
*
* Return:
* - GmailThread[] — an array of Gmail threads in the spam folder
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getSpamThreads()
*/
getSpamThreads(): GmailThread[];
/**
* Retrieves a range of spam threads irrespective of labels.
*
* // Will log a number at most 5
* Logger.log(`# of total spam threads: ${GmailApp.getSpamThreads(0, 5).length}`);
*
* Return:
* - GmailThread[] — an array of Gmail threads in the spam folder
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getSpamThreads(Integer,Integer)
* @param start the index of the first thread to retrieve
* @param max the maximum number of threads to retrieve
*/
getSpamThreads(start: Integer, max: Integer): GmailThread[];
/**
* Gets the number of unread threads that are spam.
*
* // Unless you actually read stuff in your spam folder, this should be the same
* // as the number of messages in your spam folder.
* Logger.log(`# unread threads that are spam: ${GmailApp.getSpamUnreadCount()}`);
*
* Return:
* - Integer — the number spam threads that have unread messages
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getSpamUnreadCount()
*/
getSpamUnreadCount(): Integer;
/**
* Retrieves all starred threads irrespective of labels.
* This call will fail when the size of all threads is too large for the system to handle. Where the thread size is unknown, and potentially very large, please use the 'paged' call, and specify ranges of the threads to retrieve in each call.
*
* // Logs the number of starred threads
* Logger.log(`# Starred threads: ${GmailApp.getStarredThreads().length}`);
*
* Return:
* - GmailThread[] — an array of starred Gmail threads
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getStarredThreads()
*/
getStarredThreads(): GmailThread[];
/**
* Retrieves a range of starred threads irrespective of labels.
*
* // Logs the number of starred threads to a maximum of 5
* Logger.log(`# Starred threads: ${GmailApp.getStarredThreads(0, 5).length}`);
*
* Return:
* - GmailThread[] — an array of starred Gmail threads
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getStarredThreads(Integer,Integer)
* @param start the index of the first thread to retrieve
* @param max the maximum number of threads to retrieve
*/
getStarredThreads(start: Integer, max: Integer): GmailThread[];
/**
* Gets the number of unread threads that are starred.
*
* Logger.log(`# unread and starred: ${GmailApp.getStarredUnreadCount()}`);
*
* Return:
* - Integer — the number of starred threads that have unread messages
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getStarredUnreadCount()
*/
getStarredUnreadCount(): Integer;
/**
* Gets a thread by ID.
* Use this in conjunction with getId() on Gmail threads.
*
* // Gets the first inbox thread.
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* // Gets the same thread by ID.
* const threadById = GmailApp.getThreadById(firstThread.getId());
* // Verifies that they are the same.
* console.log(
* firstThread.getFirstMessageSubject() ===
* threadById.getFirstMessageSubject(),
* );
*
* Return:
* - GmailThread — The thread with the given ID or null if not found.
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getThreadById(String)
* @param id The ID of the thread to retrieve.
*/
getThreadById(id: string): GmailThread;
/**
* Retrieves all trash threads irrespective of labels.
* This call will fail when the size of all threads is too large for the system to handle. Where the thread size is unknown, and potentially very large, please use the 'paged' call, and specify ranges of the threads to retrieve in each call.
*
* Logger.log(`# of total trash threads: ${GmailApp.getTrashThreads().length}`);
*
* Return:
* - GmailThread[] — an array of Gmail threads in the trash
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getTrashThreads()
*/
getTrashThreads(): GmailThread[];
/**
* Retrieves a range of trash threads irrespective of labels.
*
* // Will log a number at most 5
* Logger.log(
* `# of total trash threads: ${GmailApp.getTrashThreads(0, 5).length}`,
* );
*
* Return:
* - GmailThread[] — an array of Gmail threads in the trash
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getTrashThreads(Integer,Integer)
* @param start the index of the first thread to retrieve
* @param max the maximum number of threads to retrieve
*/
getTrashThreads(start: Integer, max: Integer): GmailThread[];
/**
* Retrieves a label given the label name.
*
* const labelObject = GmailApp.getUserLabelByName('myLabel');
*
* Return:
* - GmailLabel — the Gmail label with the given name
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getUserLabelByName(String)
* @param name the name of the label to retrieve
*/
getUserLabelByName(name: string): GmailLabel;
/**
* Retrieves a list of user-created labels.
*
* // Logs all of the names of your labels
* const labels = GmailApp.getUserLabels();
* for (let i = 0; i < labels.length; i++) {
* Logger.log(`label: ${labels[i].getName()}`);
* }
*
* Return:
* - GmailLabel[] — array of user created labels
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#getUserLabels()
*/
getUserLabels(): GmailLabel[];
/**
* Marks this message read and forces the message to refresh.
*
* // Mark the first message in the first thread of your inbox as read
* const message = GmailApp.getInboxThreads(0, 1)[0].getMessages()[0];
* GmailApp.markMessageRead(message);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markMessageRead(GmailMessage)
* @param message the message to mark as read
*/
markMessageRead(message: GmailMessage): GmailApp;
/**
* Marks this message unread and forces the message to refresh.
*
* // Mark the first message in the first thread of your inbox as unread
* const message = GmailApp.getInboxThreads(0, 1)[0].getMessages()[0];
* GmailApp.markMessageUnread(message);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markMessageUnread(GmailMessage)
* @param message the message to mark as unread
*/
markMessageUnread(message: GmailMessage): GmailApp;
/**
* Marks these messages read and forces the messages to refresh.
*
* // Mark first three messages in the first inbox thread as read.
* // Assumes that the first inbox thread has 3 messages in it.
* const threadMessages = GmailApp.getInboxThreads(0, 1)[0].getMessages();
* const messages = [threadMessages[0], threadMessages[1], threadMessages[2]];
* GmailApp.markMessagesRead(messages);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markMessagesRead(GmailMessage)
* @param messages an array of messages to mark as read
*/
markMessagesRead(messages: GmailMessage[]): GmailApp;
/**
* Marks these messages unread and forces the messages to refresh.
*
* // Mark first three messages in the first inbox thread as unread.
* // Assumes that the first inbox thread has 3 messages in it
* const threadMessages = GmailApp.getInboxThreads(0, 1)[0].getMessages();
* const messages = [threadMessages[0], threadMessages[1], threadMessages[2]];
* GmailApp.markMessagesUnread(messages);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markMessagesUnread(GmailMessage)
* @param messages an array of messages to mark as unread
*/
markMessagesUnread(messages: GmailMessage[]): GmailApp;
/**
* Marks this thread as important and forces the thread to refresh.
*
* // Marks first inbox thread as important
* const thread = GmailApp.getInboxThreads(0, 1)[0];
* GmailApp.markThreadImportant(thread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadImportant(GmailThread)
* @param thread the thread to mark as important
*/
markThreadImportant(thread: GmailThread): GmailApp;
/**
* Marks this thread as read and forces the thread to refresh.
*
* // Marks first inbox thread as read
* const thread = GmailApp.getInboxThreads(0, 1)[0];
* GmailApp.markThreadRead(thread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadRead(GmailThread)
* @param thread the thread to mark as read
*/
markThreadRead(thread: GmailThread): GmailApp;
/**
* Marks this thread as unimportant and forces the thread to refresh.
*
* // Marks first inbox thread as unimportant
* const thread = GmailApp.getInboxThreads(0, 1)[0];
* GmailApp.markThreadUnimportant(thread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadUnimportant(GmailThread)
* @param thread the thread to mark as unimportant
*/
markThreadUnimportant(thread: GmailThread): GmailApp;
/**
* Marks this thread unread and forces the thread to refresh.
*
* // Marks first inbox thread as unread
* const thread = GmailApp.getInboxThreads(0, 1)[0];
* GmailApp.markThreadUnread(thread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadUnread(GmailThread)
* @param thread the thread to mark as unread
*/
markThreadUnread(thread: GmailThread): GmailApp;
/**
* Marks these threads as important and forces the threads to refresh.
*
* // Marks first two threads in inbox as important
* const threads = GmailApp.getInboxThreads(0, 2);
* GmailApp.markThreadsImportant(threads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadsImportant(GmailThread)
* @param threads an array of threads to mark as important
*/
markThreadsImportant(threads: GmailThread[]): GmailApp;
/**
* Marks these threads as read and forces the threads to refresh.
*
* // Marks first two threads in inbox as read
* const threads = GmailApp.getInboxThreads(0, 2);
* GmailApp.markThreadsRead(threads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadsRead(GmailThread)
* @param threads an array of threads to mark as read
*/
markThreadsRead(threads: GmailThread[]): GmailApp;
/**
* Marks these threads as unimportant and forces the threads to refresh.
*
* // Marks first two threads in inbox as unimportant
* const threads = GmailApp.getInboxThreads(0, 2);
* GmailApp.markThreadsUnimportant(threads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadsUnimportant(GmailThread)
* @param threads an array of threads to mark as unimportant
*/
markThreadsUnimportant(threads: GmailThread[]): GmailApp;
/**
* Marks these threads as unread and forces the threads to refresh.
*
* // Marks first two threads in inbox as unread
* const threads = GmailApp.getInboxThreads(0, 2);
* GmailApp.markThreadsUnread(threads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#markThreadsUnread(GmailThread)
* @param threads an array of threads to mark as unread
*/
markThreadsUnread(threads: GmailThread[]): GmailApp;
/**
* Moves the message to the trash and forces the message to refresh.
*
* // Move the first message in your inbox to trash
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* const firstMessage = firstThread.getMessages()[0];
* GmailApp.moveMessageToTrash(firstMessage);
*
* Return:
* - GmailApp — the Gmail service (useful for chaining)
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveMessageToTrash(GmailMessage)
* @param message the message to be trashed
*/
moveMessageToTrash(message: GmailMessage): GmailApp;
/**
* Moves the specified messages to the trash and forces the messages to refresh.
*
* // Move first two messages in your inbox to trash
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* const messages = firstThread.getMessages();
* const toDelete = [messages[0], messages[1]];
* GmailApp.moveMessagesToTrash(toDelete);
*
* Return:
* - GmailApp — the Gmail service (useful for chaining)
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveMessagesToTrash(GmailMessage)
* @param messages the messages to be trashed
*/
moveMessagesToTrash(messages: GmailMessage[]): GmailApp;
/**
* Moves this thread to the archive and forces the thread to refresh.
*
* // Archive the first thread in your inbox
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* GmailApp.moveThreadToArchive(firstThread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadToArchive(GmailThread)
* @param thread the thread to be archive
*/
moveThreadToArchive(thread: GmailThread): GmailApp;
/**
* Moves this thread to the inbox and forces the thread to refresh.
*
* // Find a thread not already in your inbox
* const thread = GmailApp.search('-in:inbox')[0]; // Get the first one
* GmailApp.moveThreadToInbox(thread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadToInbox(GmailThread)
* @param thread the thread to be moved to the inbox
*/
moveThreadToInbox(thread: GmailThread): GmailApp;
/**
* Moves this thread to spam and forces the thread to refresh.
*
* // Tag first thread in inbox as spam
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* GmailApp.moveThreadToSpam(firstThread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadToSpam(GmailThread)
* @param thread the thread to be moved to spam
*/
moveThreadToSpam(thread: GmailThread): GmailApp;
/**
* Moves this thread to the trash and forces the thread to refresh.
*
* // Move first thread in inbox to trash
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* GmailApp.moveThreadToTrash(firstThread);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadToTrash(GmailThread)
* @param thread the thread to be trashed
*/
moveThreadToTrash(thread: GmailThread): GmailApp;
/**
* Moves these threads to the archive and forces the threads to refresh.
*
* // Move first two threads in your inbox to the archive
* const firstTwoThreads = GmailApp.getInboxThreads(0, 2);
* GmailApp.moveThreadsToArchive(firstTwoThreads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadsToArchive(GmailThread)
* @param threads an array of threads to be archived
*/
moveThreadsToArchive(threads: GmailThread[]): GmailApp;
/**
* Moves these threads to the inbox and forces the threads to refresh.
*
* // Find two threads not already in your inbox
* const firstTwoThreads = GmailApp.search('-in:inbox', 0, 2);
* GmailApp.moveThreadsToInbox(firstTwoThreads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadsToInbox(GmailThread)
* @param threads an array of threads to be moved to the inbox
*/
moveThreadsToInbox(threads: GmailThread[]): GmailApp;
/**
* Moves these threads to spam and forces the threads to refresh.
*
* // Move first two threads in your inbox to spam
* const firstTwoThreads = GmailApp.getInboxThreads(0, 2);
* GmailApp.moveThreadsToSpam(firstTwoThreads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadsToSpam(GmailThread)
* @param threads an array of threads to be moved to spam
*/
moveThreadsToSpam(threads: GmailThread[]): GmailApp;
/**
* Moves these threads to the trash and forces the threads to refresh.
*
* // Move first two threads in your inbox to trash
* const firstTwoThreads = GmailApp.getInboxThreads(0, 2);
* GmailApp.moveThreadsToTrash(firstTwoThreads);
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#moveThreadsToTrash(GmailThread)
* @param threads an array of threads to be trashed
*/
moveThreadsToTrash(threads: GmailThread[]): GmailApp;
/**
* Reloads the message and associated state from Gmail (useful in case the labels, read state, etc., have changed).
*
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* const firstMessage = firstThread.getMessages()[0];
* // ...Do something that may take a while here....
* GmailApp.refreshMessage(firstMessage);
* // ...Do more stuff with firstMessage...
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#refreshMessage(GmailMessage)
* @param message the message to be refreshed
*/
refreshMessage(message: GmailMessage): GmailApp;
/**
* Reloads the messages and associated state from Gmail (useful in case the labels, read state, etc., have changed).
*
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* const coupleOfMessages = firstThread.getMessages().slice(0, 2);
* // ...Do something that may take a while here....
* GmailApp.refreshMessages(coupleOfMessages);
* // ...Do more stuff with coupleOfMessages...
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#refreshMessages(GmailMessage)
* @param messages the messages to be refreshed
*/
refreshMessages(messages: GmailMessage[]): GmailApp;
/**
* Reloads the thread and associated state from Gmail (useful in case the labels, read state, etc., have changed).
*
* const firstThread = GmailApp.getInboxThreads(0, 1)[0];
* // ...Do something that may take a while here....
* GmailApp.refreshThread(firstThread);
* // ... Do more stuff with the thread ...
*
* Return:
* - GmailApp — the Gmail service, useful for chaining
*
* Authorization:
*
* Scripts that use this method require authorization with one or more of the following scopes or appropriate scopes from the related REST API:
* - https://mail.google.com/
*
* https://developers.google.com/apps-script/reference/gmail/gmail-app#refreshThread(GmailThread)
* @param thread the thread to be refreshed
*/
refreshThread(thread: GmailThread): GmailApp;
/**
* Reloads the threads and associated state from Gmail (useful in case the labels, read state, etc., have changed).
*
* const threads = GmailApp.getInboxThreads(0, 3);
* // ...Do something that may take a while here....
* GmailApp.refreshThreads(threads);
* // ... Do more stuff with threads ...
*
* Retur