Definitions for Google Apps Script

https://developers.google.com/apps-script/

from https://github.com/motemen/dts-google-apps-script/tree/c68a66fdd348ca5e5475355c503c0bcdb15d23b9

google-apps-script/NOTICE

@@ -0,0 +1,13 @@
+License Notices:
+
+The API definitions and documents are from Google Apps Script reference site [1].
+
+The document comments are reproduced from work created and shared by Google [2]
+and used according to terms described in the Creative Commons 3.0 Attribution License [3].
+
+The code samples in the documents and the test code are licensed under the Apache 2.0 License [4].
+
+[1] https://developers.google.com/apps-script/
+[2] https://developers.google.com/readme/policies/
+[3] http://creativecommons.org/licenses/by/3.0/
+[4] http://www.apache.org/licenses/LICENSE-2.0

google-apps-script/google-apps-script-tests.ts

@@ -0,0 +1,27 @@
+/// <reference path="google-apps-script.document.d.ts" />
+/// <reference path="google-apps-script.gmail.d.ts" />
+
+// from https://developers.google.com/apps-script/overview
+
+function createAndSendDocument() {
+  // Create a new Google Doc named 'Hello, world!'
+  var doc = DocumentApp.create('Hello, world!');
+
+  // Access the body of the document, then add a paragraph.
+  doc.getBody().appendParagraph('This document was created by Google Apps Script.');
+
+  // Get the URL of the document.
+  var url = doc.getUrl();
+
+  // Get the email address of the active user - that's you.
+  var email = Session.getActiveUser().getEmail();
+
+  // Get the name of the document to use as an email subject line.
+  var subject = doc.getName();
+
+  // Append a new string to the "url" variable to use as an email body.
+  var body = 'Link to your doc: ' + url;
+
+  // Send yourself an email with a link to the document.
+  GmailApp.sendEmail(email, subject, body);
+}

google-apps-script/google-apps-script.base.d.ts

@@ -0,0 +1,278 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Base {
+    /**
+     * A data interchange object for Apps Script services.
+     */
+    export interface Blob {
+      copyBlob(): Blob;
+      getAs(contentType: string): Blob;
+      getBytes(): Byte[];
+      getContentType(): string;
+      getDataAsString(): string;
+      getDataAsString(charset: string): string;
+      getName(): string;
+      isGoogleType(): boolean;
+      setBytes(data: Byte[]): Blob;
+      setContentType(contentType: string): Blob;
+      setContentTypeFromExtension(): Blob;
+      setDataFromString(string: string): Blob;
+      setDataFromString(string: string, charset: string): Blob;
+      setName(name: string): Blob;
+      getAllBlobs(): Blob[];
+    }
+
+    /**
+     * Interface for objects that can export their data as a Blob.
+     * Implementing classes
+     * 
+     * NameBrief description
+     * 
+     * AttachmentA Sites Attachment such as a file attached to a page.
+     * 
+     * BlobA data interchange object for Apps Script services.
+     * 
+     * ChartA Chart object, which can be embedded into documents, UI elements, or used as a static image.
+     * 
+     * DocumentA document, containing rich text and elements such as tables and lists.
+     * 
+     * EmbeddedChartRepresents a chart that has been embedded into a Spreadsheet.
+     * 
+     * FileA file in Google Drive.
+     * 
+     * GmailAttachmentAn attachment from Gmail.
+     * 
+     * HTTPResponseThis class allows users to access specific information on HTTP responses.
+     * 
+     * HtmlOutputAn HtmlOutput object that can be served from a script.
+     * 
+     * InlineImageAn element representing an embedded image.
+     * 
+     * JdbcBlobA JDBC Blob.
+     * 
+     * JdbcClobA JDBC Clob.
+     * 
+     * SpreadsheetThis class allows users to access and modify Google Sheets files.
+     * 
+     * StaticMapAllows for the creation and decoration of static map images.
+     */
+    export interface BlobSource {
+      getAs(contentType: string): Blob;
+      getBlob(): Blob;
+    }
+
+    /**
+     * This class provides access to Google Apps specific dialog boxes.
+     * 
+     *  The methods in this class are only available for use in the context of a Google Spreadsheet.
+     * See also
+     * 
+     * ButtonSet
+     */
+    export interface Browser {
+      Buttons: ButtonSet
+      inputBox(prompt: string): string;
+      inputBox(prompt: string, buttons: ButtonSet): string;
+      inputBox(title: string, prompt: string, buttons: ButtonSet): string;
+      msgBox(prompt: string): string;
+      msgBox(prompt: string, buttons: ButtonSet): string;
+      msgBox(title: string, prompt: string, buttons: ButtonSet): string;
+    }
+
+    /**
+     * An enum representing predetermined, localized dialog buttons returned by an
+     *  alert or PromptResponse.getSelectedButton() to
+     *  indicate which button in a dialog the user clicked. These values cannot be set; to add buttons to
+     *  an alert or
+     *  prompt, use ButtonSet instead.
+     * 
+     *      // Display a dialog box with a message and "Yes" and "No" buttons.
+     *      var ui = DocumentApp.getUi();
+     *      var response = ui.alert('Are you sure you want to continue?', ui.ButtonSet.YES_NO);
+     *     
+     *      // Process the user's response.
+     *      if (response == ui.Button.YES) {
+     *        Logger.log('The user clicked "Yes."');
+     *      } else {
+     *        Logger.log('The user clicked "No" or the dialog\'s close button.');
+     *      }
+     */
+    export enum Button { CLOSE, OK, CANCEL, YES, NO }
+
+    /**
+     * An enum representing predetermined, localized sets of one or more dialog buttons that can be
+     *  added to an alert or a
+     *  prompt. To determine which button the user
+     *  clicked, use Button.
+     * 
+     *      // Display a dialog box with a message and "Yes" and "No" buttons.
+     *      var ui = DocumentApp.getUi();
+     *      var response = ui.alert('Are you sure you want to continue?', ui.ButtonSet.YES_NO);
+     *     
+     *      // Process the user's response.
+     *      if (response == ui.Button.YES) {
+     *        Logger.log('The user clicked "Yes."');
+     *      } else {
+     *        Logger.log('The user clicked "No" or the dialog\'s close button.');
+     *      }
+     */
+    export enum ButtonSet { OK, OK_CANCEL, YES_NO, YES_NO_CANCEL }
+
+    /**
+     * This class allows the developer to write out text to the debugging logs.
+     */
+    export interface Logger {
+      clear(): void;
+      getLog(): string;
+      log(data: Object): Logger;
+      log(format: string, ...values: Object[]): Logger;
+    }
+
+    /**
+     * A custom menu in an instance of the user interface for a Google App. A script can only interact
+     *  with the UI for the current instance of an open document or form, and only if the script is
+     *  container-bound to the document or form. For more
+     *  information, see the guide to menus.
+     * 
+     *      // Add a custom menu to the active spreadsheet, including a separator and a sub-menu.
+     *      function onOpen(e) {
+     *        SpreadsheetApp.getUi()
+     *            .createMenu('My Menu')
+     *            .addItem('My Menu Item', 'myFunction')
+     *            .addSeparator()
+     *            .addSubMenu(SpreadsheetApp.getUi().createMenu('My Submenu')
+     *                .addItem('One Submenu Item', 'mySecondFunction')
+     *                .addItem('Another Submenu Item', 'myThirdFunction'))
+     *            .addToUi();
+     *      }
+     */
+    export interface Menu {
+      addItem(caption: string, functionName: string): Menu;
+      addSeparator(): Menu;
+      addSubMenu(menu: Menu): Menu;
+      addToUi(): void;
+    }
+
+    /**
+     * An enumeration that provides access to MIME-type declarations without typing the strings
+     *  explicitly. Any method that expects a MIME type rendered as a string (for example,
+     *  'image/png') will also accept one of the values below, so long as the method
+     *  supports the underlying MIME type.
+     * 
+     *      // Use MimeType enum to log the name of every Google Doc in the user's Drive.
+     *      var docs = DriveApp.getFilesByType(MimeType.GOOGLE_DOCS);
+     *      while (docs.hasNext()) {
+     *       var doc = docs.next();
+     *       Logger.log(doc.getName())
+     *      }
+     *     
+     *      // Use plain string to log the size of every PNG in the user's Drive.
+     *      var pngs = DriveApp.getFilesByType('image/png');
+     *      while (pngs.hasNext()) {
+     *       var png = pngs.next();
+     *       Logger.log(png.getSize());
+     *      }
+     */
+    export enum MimeType { GOOGLE_APPS_SCRIPT, GOOGLE_DRAWINGS, GOOGLE_DOCS, GOOGLE_FORMS, GOOGLE_SHEETS, GOOGLE_SLIDES, FOLDER, BMP, GIF, JPEG, PNG, SVG, PDF, CSS, CSV, HTML, JAVASCRIPT, PLAIN_TEXT, RTF, OPENDOCUMENT_GRAPHICS, OPENDOCUMENT_PRESENTATION, OPENDOCUMENT_SPREADSHEET, OPENDOCUMENT_TEXT, MICROSOFT_EXCEL, MICROSOFT_EXCEL_LEGACY, MICROSOFT_POWERPOINT, MICROSOFT_POWERPOINT_LEGACY, MICROSOFT_WORD, MICROSOFT_WORD_LEGACY, ZIP }
+
+    /**
+     * An enum representing the months of the year.
+     */
+    export enum Month { JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER }
+
+    /**
+     * A response to a prompt dialog displayed in the
+     *  user-interface environment for a Google App. The response contains any text the user entered in
+     *  the dialog's input field and indicates which button the user clicked to dismiss the dialog.
+     * 
+     *      // Display a dialog box with a title, message, input field, and "Yes" and "No" buttons. The
+     *      // user can also close the dialog by clicking the close button in its title bar.
+     *      var ui = DocumentApp.getUi();
+     *      var response = ui.prompt('Getting to know you', 'May I know your name?', ui.ButtonSet.YES_NO);
+     *     
+     *      // Process the user's response.
+     *      if (response.getSelectedButton() == ui.Button.YES) {
+     *        Logger.log('The user\'s name is %s.', response.getResponseText());
+     *      } else if (response.getSelectedButton() == ui.Button.NO) {
+     *        Logger.log('The user didn\'t want to provide a name.');
+     *      } else {
+     *        Logger.log('The user clicked the close button in the dialog\'s title bar.');
+     *      }
+     */
+    export interface PromptResponse {
+      getResponseText(): string;
+      getSelectedButton(): Button;
+    }
+
+    /**
+     * The Session class provides access to session information, such as the user's email address (in
+     *  some circumstances) and language setting.
+     */
+    export interface Session {
+      getActiveUser(): User;
+      getActiveUserLocale(): string;
+      getEffectiveUser(): User;
+      getScriptTimeZone(): string;
+      getTimeZone(): string;
+      getUser(): User;
+    }
+
+    /**
+     * An instance of the user-interface environment for a Google App that allows the script to add
+     *  features like menus, dialogs, and sidebars. A script can only interact with the UI for the
+     *  current instance of an open editor, and only if the script is
+     *  container-bound to the editor.
+     * 
+     *      // Display a dialog box with a title, message, input field, and "Yes" and "No" buttons. The
+     *      // user can also close the dialog by clicking the close button in its title bar.
+     *      var ui = SpreadsheetApp.getUi();
+     *      var response = ui.prompt('Getting to know you', 'May I know your name?', ui.ButtonSet.YES_NO);
+     *     
+     *      // Process the user's response.
+     *      if (response.getSelectedButton() == ui.Button.YES) {
+     *        Logger.log('The user\'s name is %s.', response.getResponseText());
+     *      } else if (response.getSelectedButton() == ui.Button.NO) {
+     *        Logger.log('The user didn\'t want to provide a name.');
+     *      } else {
+     *        Logger.log('The user clicked the close button in the dialog\'s title bar.');
+     *      }
+     */
+    export interface Ui {
+      Button: Button
+      ButtonSet: ButtonSet
+      alert(prompt: string): Button;
+      alert(prompt: string, buttons: ButtonSet): Button;
+      alert(title: string, prompt: string, buttons: ButtonSet): Button;
+      createAddonMenu(): Menu;
+      createMenu(caption: string): Menu;
+      prompt(prompt: string): PromptResponse;
+      prompt(prompt: string, buttons: ButtonSet): PromptResponse;
+      prompt(title: string, prompt: string, buttons: ButtonSet): PromptResponse;
+      showModalDialog(userInterface: Object, title: string): void;
+      showModelessDialog(userInterface: Object, title: string): void;
+      showSidebar(userInterface: Object): void;
+      showDialog(userInterface: Object): void;
+    }
+
+    /**
+     * Representation of a user, suitable for scripting.
+     */
+    export interface User {
+      getEmail(): string;
+      getUserLoginId(): string;
+    }
+
+    /**
+     * An enum representing the days of the week.
+     */
+    export enum Weekday { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY }
+
+  }
+}
+
+declare var Browser: GoogleAppsScript.Base.Browser;
+declare var Logger: GoogleAppsScript.Base.Logger;
+// conflicts with MimeType in lib.d.ts
+// declare var MimeType: GoogleAppsScript.Base.MimeType;
+declare var Session: GoogleAppsScript.Base.Session;

google-apps-script/google-apps-script.cache.d.ts

@@ -0,0 +1,52 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Cache {
+    /**
+     * A reference to a particular cache.
+     * 
+     *  This class allows you to insert, retrieve, and remove items from a cache. This can be
+     *  particularly useful when you want frequent access to an expensive or slow resource. For
+     *  example, say you have an RSS feed at example.com that takes 20 seconds to fetch, but you want
+     *  to speed up access on an average request.
+     * 
+     *      function getRssFeed() {
+     *        var cache = CacheService.getPublicCache();
+     *        var cached = cache.get("rss-feed-contents");
+     *        if (cached != null) {
+     *          return cached;
+     *        }
+     *        var result = UrlFetchApp.fetch("http://example.com/my-slow-rss-feed.xml"); // takes 20 seconds
+     *        var contents = result.getContentText();
+     *        cache.put("rss-feed-contents", contents, 1500); // cache for 25 minutes
+     *        return contents;
+     *      }
+     */
+    export interface Cache {
+      get(key: string): string;
+      getAll(keys: String[]): Object;
+      put(key: string, value: string): void;
+      put(key: string, value: string, expirationInSeconds: Integer): void;
+      putAll(values: Object): void;
+      putAll(values: Object, expirationInSeconds: Integer): void;
+      remove(key: string): void;
+      removeAll(keys: String[]): void;
+    }
+
+    /**
+     * CacheService allows you to access a cache for short term storage of data.
+     * 
+     *  This class lets you get a specific cache instance. Public caches are for things that are not
+     *  dependent on which user is accessing your script. Private caches are for things which are
+     *  user-specific, like settings or recent activity.
+     */
+    export interface CacheService {
+      getDocumentCache(): Cache;
+      getScriptCache(): Cache;
+      getUserCache(): Cache;
+    }
+
+  }
+}
+
+declare var CacheService: GoogleAppsScript.Cache.CacheService;

google-apps-script/google-apps-script.calendar.d.ts

@@ -0,0 +1,289 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Calendar {
+    /**
+     * Represents a calendar that the user owns or is subscribed to.
+     */
+    export interface Calendar {
+      createAllDayEvent(title: string, date: Date): CalendarEvent;
+      createAllDayEvent(title: string, date: Date, options: Object): CalendarEvent;
+      createAllDayEventSeries(title: string, startDate: Date, recurrence: EventRecurrence): CalendarEventSeries;
+      createAllDayEventSeries(title: string, startDate: Date, recurrence: EventRecurrence, options: Object): CalendarEventSeries;
+      createEvent(title: string, startTime: Date, endTime: Date): CalendarEvent;
+      createEvent(title: string, startTime: Date, endTime: Date, options: Object): CalendarEvent;
+      createEventFromDescription(description: string): CalendarEvent;
+      createEventSeries(title: string, startTime: Date, endTime: Date, recurrence: EventRecurrence): CalendarEventSeries;
+      createEventSeries(title: string, startTime: Date, endTime: Date, recurrence: EventRecurrence, options: Object): CalendarEventSeries;
+      deleteCalendar(): void;
+      getColor(): string;
+      getDescription(): string;
+      getEventSeriesById(iCalId: string): CalendarEventSeries;
+      getEvents(startTime: Date, endTime: Date): CalendarEvent[];
+      getEvents(startTime: Date, endTime: Date, options: Object): CalendarEvent[];
+      getEventsForDay(date: Date): CalendarEvent[];
+      getEventsForDay(date: Date, options: Object): CalendarEvent[];
+      getId(): string;
+      getName(): string;
+      getTimeZone(): string;
+      isHidden(): boolean;
+      isMyPrimaryCalendar(): boolean;
+      isOwnedByMe(): boolean;
+      isSelected(): boolean;
+      setColor(color: string): Calendar;
+      setDescription(description: string): Calendar;
+      setHidden(hidden: boolean): Calendar;
+      setName(name: string): Calendar;
+      setSelected(selected: boolean): Calendar;
+      setTimeZone(timeZone: string): Calendar;
+      unsubscribeFromCalendar(): void;
+    }
+
+    /**
+     * Allows a script to read and update the user's Google Calendar. This class provides direct
+     *  access to the user's default calendar, as well as the ability to retrieve additional calendars
+     *  that the user owns or is subscribed to.
+     */
+    export interface CalendarApp {
+      Color: Color
+      GuestStatus: GuestStatus
+      Month: Base.Month
+      Visibility: Visibility
+      Weekday: Base.Weekday
+      createAllDayEvent(title: string, date: Date): CalendarEvent;
+      createAllDayEvent(title: string, date: Date, options: Object): CalendarEvent;
+      createAllDayEventSeries(title: string, startDate: Date, recurrence: EventRecurrence): CalendarEventSeries;
+      createAllDayEventSeries(title: string, startDate: Date, recurrence: EventRecurrence, options: Object): CalendarEventSeries;
+      createCalendar(name: string): Calendar;
+      createCalendar(name: string, options: Object): Calendar;
+      createEvent(title: string, startTime: Date, endTime: Date): CalendarEvent;
+      createEvent(title: string, startTime: Date, endTime: Date, options: Object): CalendarEvent;
+      createEventFromDescription(description: string): CalendarEvent;
+      createEventSeries(title: string, startTime: Date, endTime: Date, recurrence: EventRecurrence): CalendarEventSeries;
+      createEventSeries(title: string, startTime: Date, endTime: Date, recurrence: EventRecurrence, options: Object): CalendarEventSeries;
+      getAllCalendars(): Calendar[];
+      getAllOwnedCalendars(): Calendar[];
+      getCalendarById(id: string): Calendar;
+      getCalendarsByName(name: string): Calendar[];
+      getColor(): string;
+      getDefaultCalendar(): Calendar;
+      getDescription(): string;
+      getEventSeriesById(iCalId: string): CalendarEventSeries;
+      getEvents(startTime: Date, endTime: Date): CalendarEvent[];
+      getEvents(startTime: Date, endTime: Date, options: Object): CalendarEvent[];
+      getEventsForDay(date: Date): CalendarEvent[];
+      getEventsForDay(date: Date, options: Object): CalendarEvent[];
+      getId(): string;
+      getName(): string;
+      getOwnedCalendarById(id: string): Calendar;
+      getOwnedCalendarsByName(name: string): Calendar[];
+      getTimeZone(): string;
+      isHidden(): boolean;
+      isMyPrimaryCalendar(): boolean;
+      isOwnedByMe(): boolean;
+      isSelected(): boolean;
+      newRecurrence(): EventRecurrence;
+      setColor(color: string): Calendar;
+      setDescription(description: string): Calendar;
+      setHidden(hidden: boolean): Calendar;
+      setName(name: string): Calendar;
+      setSelected(selected: boolean): Calendar;
+      setTimeZone(timeZone: string): Calendar;
+      subscribeToCalendar(id: string): Calendar;
+      subscribeToCalendar(id: string, options: Object): Calendar;
+    }
+
+    /**
+     * Represents a single calendar event.
+     */
+    export interface CalendarEvent {
+      addEmailReminder(minutesBefore: Integer): CalendarEvent;
+      addGuest(email: string): CalendarEvent;
+      addPopupReminder(minutesBefore: Integer): CalendarEvent;
+      addSmsReminder(minutesBefore: Integer): CalendarEvent;
+      anyoneCanAddSelf(): boolean;
+      deleteEvent(): void;
+      deleteTag(key: string): CalendarEvent;
+      getAllDayEndDate(): Date;
+      getAllDayStartDate(): Date;
+      getAllTagKeys(): String[];
+      getCreators(): String[];
+      getDateCreated(): Date;
+      getDescription(): string;
+      getEmailReminders(): Integer[];
+      getEndTime(): Date;
+      getEventSeries(): CalendarEventSeries;
+      getGuestByEmail(email: string): EventGuest;
+      getGuestList(): EventGuest[];
+      getGuestList(includeOwner: boolean): EventGuest[];
+      getId(): string;
+      getLastUpdated(): Date;
+      getLocation(): string;
+      getMyStatus(): GuestStatus;
+      getOriginalCalendarId(): string;
+      getPopupReminders(): Integer[];
+      getSmsReminders(): Integer[];
+      getStartTime(): Date;
+      getTag(key: string): string;
+      getTitle(): string;
+      getVisibility(): Visibility;
+      guestsCanInviteOthers(): boolean;
+      guestsCanModify(): boolean;
+      guestsCanSeeGuests(): boolean;
+      isAllDayEvent(): boolean;
+      isOwnedByMe(): boolean;
+      isRecurringEvent(): boolean;
+      removeAllReminders(): CalendarEvent;
+      removeGuest(email: string): CalendarEvent;
+      resetRemindersToDefault(): CalendarEvent;
+      setAllDayDate(date: Date): CalendarEvent;
+      setAnyoneCanAddSelf(anyoneCanAddSelf: boolean): CalendarEvent;
+      setDescription(description: string): CalendarEvent;
+      setGuestsCanInviteOthers(guestsCanInviteOthers: boolean): CalendarEvent;
+      setGuestsCanModify(guestsCanModify: boolean): CalendarEvent;
+      setGuestsCanSeeGuests(guestsCanSeeGuests: boolean): CalendarEvent;
+      setLocation(location: string): CalendarEvent;
+      setMyStatus(status: GuestStatus): CalendarEvent;
+      setTag(key: string, value: string): CalendarEvent;
+      setTime(startTime: Date, endTime: Date): CalendarEvent;
+      setTitle(title: string): CalendarEvent;
+      setVisibility(visibility: Visibility): CalendarEvent;
+    }
+
+    /**
+     * Represents a series of events (a recurring event).
+     */
+    export interface CalendarEventSeries {
+      addEmailReminder(minutesBefore: Integer): CalendarEventSeries;
+      addGuest(email: string): CalendarEventSeries;
+      addPopupReminder(minutesBefore: Integer): CalendarEventSeries;
+      addSmsReminder(minutesBefore: Integer): CalendarEventSeries;
+      anyoneCanAddSelf(): boolean;
+      deleteEventSeries(): void;
+      deleteTag(key: string): CalendarEventSeries;
+      getAllTagKeys(): String[];
+      getCreators(): String[];
+      getDateCreated(): Date;
+      getDescription(): string;
+      getEmailReminders(): Integer[];
+      getGuestByEmail(email: string): EventGuest;
+      getGuestList(): EventGuest[];
+      getGuestList(includeOwner: boolean): EventGuest[];
+      getId(): string;
+      getLastUpdated(): Date;
+      getLocation(): string;
+      getMyStatus(): GuestStatus;
+      getOriginalCalendarId(): string;
+      getPopupReminders(): Integer[];
+      getSmsReminders(): Integer[];
+      getTag(key: string): string;
+      getTitle(): string;
+      getVisibility(): Visibility;
+      guestsCanInviteOthers(): boolean;
+      guestsCanModify(): boolean;
+      guestsCanSeeGuests(): boolean;
+      isOwnedByMe(): boolean;
+      removeAllReminders(): CalendarEventSeries;
+      removeGuest(email: string): CalendarEventSeries;
+      resetRemindersToDefault(): CalendarEventSeries;
+      setAnyoneCanAddSelf(anyoneCanAddSelf: boolean): CalendarEventSeries;
+      setDescription(description: string): CalendarEventSeries;
+      setGuestsCanInviteOthers(guestsCanInviteOthers: boolean): CalendarEventSeries;
+      setGuestsCanModify(guestsCanModify: boolean): CalendarEventSeries;
+      setGuestsCanSeeGuests(guestsCanSeeGuests: boolean): CalendarEventSeries;
+      setLocation(location: string): CalendarEventSeries;
+      setMyStatus(status: GuestStatus): CalendarEventSeries;
+      setRecurrence(recurrence: EventRecurrence, startDate: Date): CalendarEventSeries;
+      setRecurrence(recurrence: EventRecurrence, startTime: Date, endTime: Date): CalendarEventSeries;
+      setTag(key: string, value: string): CalendarEventSeries;
+      setTitle(title: string): CalendarEventSeries;
+      setVisibility(visibility: Visibility): CalendarEventSeries;
+    }
+
+    /**
+     * An enum representing the named colors available in the Calendar service.
+     */
+    export enum Color { BLUE, BROWN, CHARCOAL, CHESTNUT, GRAY, GREEN, INDIGO, LIME, MUSTARD, OLIVE, ORANGE, PINK, PLUM, PURPLE, RED, RED_ORANGE, SEA_BLUE, SLATE, TEAL, TURQOISE, YELLOW }
+
+    /**
+     * Represents a guest of an event.
+     */
+    export interface EventGuest {
+      getAdditionalGuests(): Integer;
+      getEmail(): string;
+      getGuestStatus(): GuestStatus;
+      getName(): string;
+      getStatus(): string;
+    }
+
+    /**
+     * Represents the recurrence settings for an event series.
+     */
+    export interface EventRecurrence {
+      addDailyExclusion(): RecurrenceRule;
+      addDailyRule(): RecurrenceRule;
+      addDate(date: Date): EventRecurrence;
+      addDateExclusion(date: Date): EventRecurrence;
+      addMonthlyExclusion(): RecurrenceRule;
+      addMonthlyRule(): RecurrenceRule;
+      addWeeklyExclusion(): RecurrenceRule;
+      addWeeklyRule(): RecurrenceRule;
+      addYearlyExclusion(): RecurrenceRule;
+      addYearlyRule(): RecurrenceRule;
+      setTimeZone(timeZone: string): EventRecurrence;
+    }
+
+    /**
+     * An enum representing the statuses a guest can have for an event.
+     */
+    export enum GuestStatus { INVITED, MAYBE, NO, OWNER, YES }
+
+    /**
+     * Represents a recurrence rule for an event series.
+     * 
+     * Note that this class also behaves like the EventRecurrence that it belongs
+     *  to, allowing you to chain rule creation together like so:
+     * 
+     *      recurrence.addDailyRule().times(3).interval(2).addWeeklyExclusion().times(2);
+     * 
+     * times(times)
+     * interval(interval)
+     */
+    export interface RecurrenceRule {
+      addDailyExclusion(): RecurrenceRule;
+      addDailyRule(): RecurrenceRule;
+      addDate(date: Date): EventRecurrence;
+      addDateExclusion(date: Date): EventRecurrence;
+      addMonthlyExclusion(): RecurrenceRule;
+      addMonthlyRule(): RecurrenceRule;
+      addWeeklyExclusion(): RecurrenceRule;
+      addWeeklyRule(): RecurrenceRule;
+      addYearlyExclusion(): RecurrenceRule;
+      addYearlyRule(): RecurrenceRule;
+      interval(interval: Integer): RecurrenceRule;
+      onlyInMonth(month: Base.Month): RecurrenceRule;
+      onlyInMonths(months: Base.Month[]): RecurrenceRule;
+      onlyOnMonthDay(day: Integer): RecurrenceRule;
+      onlyOnMonthDays(days: Integer[]): RecurrenceRule;
+      onlyOnWeek(week: Integer): RecurrenceRule;
+      onlyOnWeekday(day: Base.Weekday): RecurrenceRule;
+      onlyOnWeekdays(days: Base.Weekday[]): RecurrenceRule;
+      onlyOnWeeks(weeks: Integer[]): RecurrenceRule;
+      onlyOnYearDay(day: Integer): RecurrenceRule;
+      onlyOnYearDays(days: Integer[]): RecurrenceRule;
+      setTimeZone(timeZone: string): EventRecurrence;
+      times(times: Integer): RecurrenceRule;
+      until(endDate: Date): RecurrenceRule;
+      weekStartsOn(day: Base.Weekday): RecurrenceRule;
+    }
+
+    /**
+     * An enum representing the visibility of an event.
+     */
+    export enum Visibility { CONFIDENTIAL, DEFAULT, PRIVATE, PUBLIC }
+
+  }
+}
+
+declare var CalendarApp: GoogleAppsScript.Calendar.CalendarApp;

google-apps-script/google-apps-script.charts.d.ts

@@ -0,0 +1,970 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+/// <reference path="google-apps-script.ui.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Charts {
+    /**
+     * Builder for area charts. For more details, see the 
+     *  Google Charts documentation.
+     * 
+     *  Here is an example that shows how to build an area chart.
+     * 
+     *      function doGet() {
+     *        // Create a data table with some sample data.
+     *        var sampleData = Charts.newDataTable()
+     *            .addColumn(Charts.ColumnType.STRING, "Month")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Dining")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Total")
+     *            .addRow(["Jan", 60, 520])
+     *            .addRow(["Feb", 50, 430])
+     *            .addRow(["Mar", 53, 440])
+     *            .addRow(["Apr", 70, 410])
+     *            .addRow(["May", 80, 390])
+     *            .addRow(["Jun", 60, 500])
+     *            .addRow(["Jul", 100, 450])
+     *            .addRow(["Aug", 140, 431])
+     *            .addRow(["Sep", 75, 488])
+     *            .addRow(["Oct", 70, 521])
+     *            .addRow(["Nov", 58, 388])
+     *            .addRow(["Dec", 63, 400])
+     *            .build();
+     *        
+     *        var chart = Charts.newAreaChart()
+     *            .setTitle('Yearly Spending')
+     *            .setXAxisTitle('Month')
+     *            .setYAxisTitle('Spending (USD)')
+     *            .setDimensions(600, 500)
+     *            .setStacked()
+     *            .setColors(['red', 'green'])
+     *            .setDataTable(sampleData)
+     *            .build();
+     *        
+     *        return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface AreaChartBuilder {
+      build(): Chart;
+      reverseCategories(): AreaChartBuilder;
+      setBackgroundColor(cssValue: string): AreaChartBuilder;
+      setColors(cssValues: String[]): AreaChartBuilder;
+      setDataSourceUrl(url: string): AreaChartBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): AreaChartBuilder;
+      setDataTable(table: DataTableSource): AreaChartBuilder;
+      setDataViewDefinition(dataViewDefinition: DataViewDefinition): AreaChartBuilder;
+      setDimensions(width: Integer, height: Integer): AreaChartBuilder;
+      setLegendPosition(position: Position): AreaChartBuilder;
+      setLegendTextStyle(textStyle: TextStyle): AreaChartBuilder;
+      setOption(option: string, value: Object): AreaChartBuilder;
+      setPointStyle(style: PointStyle): AreaChartBuilder;
+      setRange(start: Number, end: Number): AreaChartBuilder;
+      setStacked(): AreaChartBuilder;
+      setTitle(chartTitle: string): AreaChartBuilder;
+      setTitleTextStyle(textStyle: TextStyle): AreaChartBuilder;
+      setXAxisTextStyle(textStyle: TextStyle): AreaChartBuilder;
+      setXAxisTitle(title: string): AreaChartBuilder;
+      setXAxisTitleTextStyle(textStyle: TextStyle): AreaChartBuilder;
+      setYAxisTextStyle(textStyle: TextStyle): AreaChartBuilder;
+      setYAxisTitle(title: string): AreaChartBuilder;
+      setYAxisTitleTextStyle(textStyle: TextStyle): AreaChartBuilder;
+      useLogScale(): AreaChartBuilder;
+    }
+
+    /**
+     * Builder for bar charts. For more details, see the 
+     *  Google Charts documentation.
+     * 
+     *  Here is an example that shows how to build a bar chart. The data is 
+     *  
+     *  imported from a Google spreadsheet.
+     * 
+     *      function doGet() {
+     *       // Get sample data from a spreadsheet.
+     *       var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=B1%3AC11' +
+     *           '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=0&headers=-1';
+     *     
+     *       var chartBuilder = Charts.newBarChart()
+     *           .setTitle('Top Grossing Films in US and Canada')
+     *           .setXAxisTitle('USD')
+     *           .setYAxisTitle('Film')
+     *           .setDimensions(600, 500)
+     *           .setLegendPosition(Charts.Position.BOTTOM)
+     *           .setDataSourceUrl(dataSourceUrl);
+     *     
+     *       var chart = chartBuilder.build();
+     *       return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface BarChartBuilder {
+      build(): Chart;
+      reverseCategories(): BarChartBuilder;
+      reverseDirection(): BarChartBuilder;
+      setBackgroundColor(cssValue: string): BarChartBuilder;
+      setColors(cssValues: String[]): BarChartBuilder;
+      setDataSourceUrl(url: string): BarChartBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): BarChartBuilder;
+      setDataTable(table: DataTableSource): BarChartBuilder;
+      setDataViewDefinition(dataViewDefinition: DataViewDefinition): BarChartBuilder;
+      setDimensions(width: Integer, height: Integer): BarChartBuilder;
+      setLegendPosition(position: Position): BarChartBuilder;
+      setLegendTextStyle(textStyle: TextStyle): BarChartBuilder;
+      setOption(option: string, value: Object): BarChartBuilder;
+      setRange(start: Number, end: Number): BarChartBuilder;
+      setStacked(): BarChartBuilder;
+      setTitle(chartTitle: string): BarChartBuilder;
+      setTitleTextStyle(textStyle: TextStyle): BarChartBuilder;
+      setXAxisTextStyle(textStyle: TextStyle): BarChartBuilder;
+      setXAxisTitle(title: string): BarChartBuilder;
+      setXAxisTitleTextStyle(textStyle: TextStyle): BarChartBuilder;
+      setYAxisTextStyle(textStyle: TextStyle): BarChartBuilder;
+      setYAxisTitle(title: string): BarChartBuilder;
+      setYAxisTitleTextStyle(textStyle: TextStyle): BarChartBuilder;
+      useLogScale(): BarChartBuilder;
+    }
+
+    /**
+     * A builder for category filter controls.
+     * 
+     *  A category filter is a picker to choose one or more between a set of defined values.
+     *  Given a column of type string, this control will filter out the rows that
+     *  don't match any of the picked values.
+     * 
+     *  Here is an example that creates a table chart a binds a category filter to it. This allows the
+     *  user to filter the data the table displays.
+     * 
+     *      function doGet() {
+     *        var app = UiApp.createApplication();
+     *        var sampleData = Charts.newDataTable()
+     *            .addColumn(Charts.ColumnType.STRING, "Month")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Dining")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Total")
+     *            .addRow(["Jan", 60, 520])
+     *            .addRow(["Feb", 50, 430])
+     *            .addRow(["Mar", 53, 440])
+     *            .addRow(["Apr", 70, 410])
+     *            .addRow(["May", 80, 390])
+     *            .addRow(["Jun", 60, 500])
+     *            .addRow(["Jul", 100, 450])
+     *            .addRow(["Aug", 140, 431])
+     *            .addRow(["Sep", 75, 488])
+     *            .addRow(["Oct", 70, 521])
+     *            .addRow(["Nov", 58, 388])
+     *            .addRow(["Dec", 63, 400])
+     *            .build();
+     *            
+     *        var chart = Charts.newTableChart()
+     *            .setDimensions(600, 500)
+     *            .build();
+     *            
+     *        var categoryFilter = Charts.newCategoryFilter()
+     *            .setFilterColumnLabel("Month")
+     *            .setAllowMultiple(true)
+     *            .setSortValues(true)
+     *            .setLabelStacking(Charts.Orientation.VERTICAL)
+     *            .setCaption('Choose categories...')
+     *            .build();
+     *        
+     *        var panel = app.createVerticalPanel().setSpacing(10);
+     *        panel.add(categoryFilter).add(chart);
+     *        
+     *        var dashboard = Charts.newDashboardPanel()
+     *            .setDataTable(sampleData)
+     *            .bind(categoryFilter, chart)
+     *            .build();
+     *            
+     *        dashboard.add(panel);
+     *        app.add(dashboard);
+     *        return app;
+     *      }
+     * 
+     *  documentation
+     */
+    export interface CategoryFilterBuilder {
+      build(): Control;
+      setAllowMultiple(allowMultiple: boolean): CategoryFilterBuilder;
+      setAllowNone(allowNone: boolean): CategoryFilterBuilder;
+      setAllowTyping(allowTyping: boolean): CategoryFilterBuilder;
+      setCaption(caption: string): CategoryFilterBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): CategoryFilterBuilder;
+      setDataTable(table: DataTableSource): CategoryFilterBuilder;
+      setFilterColumnIndex(columnIndex: Integer): CategoryFilterBuilder;
+      setFilterColumnLabel(columnLabel: string): CategoryFilterBuilder;
+      setLabel(label: string): CategoryFilterBuilder;
+      setLabelSeparator(labelSeparator: string): CategoryFilterBuilder;
+      setLabelStacking(orientation: Orientation): CategoryFilterBuilder;
+      setSelectedValuesLayout(layout: PickerValuesLayout): CategoryFilterBuilder;
+      setSortValues(sortValues: boolean): CategoryFilterBuilder;
+      setValues(values: String[]): CategoryFilterBuilder;
+    }
+
+    /**
+     * A Chart object, which can be embedded into documents, UI elements, or used as a static image. For
+     *  charts embedded in spreadsheets, see
+     *  EmbeddedChart.
+     */
+    export interface Chart {
+      getAs(contentType: string): Base.Blob;
+      getBlob(): Base.Blob;
+      getId(): string;
+      getOptions(): ChartOptions;
+      getType(): string;
+      setId(id: string): Chart;
+    }
+
+    /**
+     * Exposes options currently configured for a Chart, such as height, color, etc.
+     * 
+     *  Please see the visualization
+     *  reference documentation for information on what options are available. Specific options for
+     *  each chart can be found by clicking on the specific chart in the chart gallery.
+     * 
+     *  These options are immutable.
+     */
+    export interface ChartOptions {
+      get(option: string): Object;
+    }
+
+    /**
+     * Chart types supported by the Charts service.
+     */
+    export enum ChartType { AREA, BAR, COLUMN, LINE, PIE, SCATTER, TABLE }
+
+    /**
+     * Entry point for creating Charts in scripts.
+     * 
+     *  This example creates a basic data table, populates an area chart with the data, and adds it into
+     *  a UiApp:
+     * 
+     *      function doGet() {
+     *        var data = Charts.newDataTable()
+     *            .addColumn(Charts.ColumnType.STRING, "Month")
+     *            .addColumn(Charts.ColumnType.NUMBER, "In Store")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Online")
+     *            .addRow(["January", 10, 1])
+     *            .addRow(["February", 12, 1])
+     *            .addRow(["March", 20, 2])
+     *            .addRow(["April", 25, 3])
+     *            .addRow(["May", 30, 4])
+     *            .build();
+     *     
+     *        var chart = Charts.newAreaChart()
+     *            .setDataTable(data)
+     *            .setStacked()
+     *            .setRange(0, 40)
+     *            .setTitle("Sales per Month")
+     *            .build();
+     *     
+     *        var uiApp = UiApp.createApplication().setTitle("My Chart");
+     *        uiApp.add(chart);
+     *        return uiApp;
+     *      }
+     */
+    export interface Charts {
+      ChartType: ChartType
+      ColumnType: ColumnType
+      CurveStyle: CurveStyle
+      MatchType: MatchType
+      Orientation: Orientation
+      PickerValuesLayout: PickerValuesLayout
+      PointStyle: PointStyle
+      Position: Position
+      newAreaChart(): AreaChartBuilder;
+      newBarChart(): BarChartBuilder;
+      newCategoryFilter(): CategoryFilterBuilder;
+      newColumnChart(): ColumnChartBuilder;
+      newDashboardPanel(): DashboardPanelBuilder;
+      newDataTable(): DataTableBuilder;
+      newDataViewDefinition(): DataViewDefinitionBuilder;
+      newLineChart(): LineChartBuilder;
+      newNumberRangeFilter(): NumberRangeFilterBuilder;
+      newPieChart(): PieChartBuilder;
+      newScatterChart(): ScatterChartBuilder;
+      newStringFilter(): StringFilterBuilder;
+      newTableChart(): TableChartBuilder;
+      newTextStyle(): TextStyleBuilder;
+    }
+
+    /**
+     * Builder for column charts. For more details, see the 
+     *  Google Charts documentation.
+     * 
+     *  This example shows how to create a column chart with data from a data table.
+     * 
+     *       function doGet() {
+     *        var sampleData = Charts.newDataTable()
+     *            .addColumn(Charts.ColumnType.STRING, "Year")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Sales")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Expenses")
+     *            .addRow(["2004", 1000, 400])
+     *            .addRow(["2005", 1170, 460])
+     *            .addRow(["2006", 660, 1120])
+     *            .addRow(["2007", 1030, 540])
+     *            .addRow(["2008", 800, 600])
+     *            .addRow(["2009", 943, 678])
+     *            .addRow(["2010", 1020, 550])
+     *            .addRow(["2011", 910, 700])
+     *            .addRow(["2012", 1230, 840])
+     *            .build();
+     *        
+     *        var chart = Charts.newColumnChart()
+     *            .setTitle('Sales vs. Expenses')
+     *            .setXAxisTitle('Year')
+     *            .setYAxisTitle('Amount (USD)')
+     *            .setDimensions(600, 500)
+     *            .setDataTable(sampleData)
+     *            .build();
+     *        
+     *        return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface ColumnChartBuilder {
+      build(): Chart;
+      reverseCategories(): ColumnChartBuilder;
+      setBackgroundColor(cssValue: string): ColumnChartBuilder;
+      setColors(cssValues: String[]): ColumnChartBuilder;
+      setDataSourceUrl(url: string): ColumnChartBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): ColumnChartBuilder;
+      setDataTable(table: DataTableSource): ColumnChartBuilder;
+      setDataViewDefinition(dataViewDefinition: DataViewDefinition): ColumnChartBuilder;
+      setDimensions(width: Integer, height: Integer): ColumnChartBuilder;
+      setLegendPosition(position: Position): ColumnChartBuilder;
+      setLegendTextStyle(textStyle: TextStyle): ColumnChartBuilder;
+      setOption(option: string, value: Object): ColumnChartBuilder;
+      setRange(start: Number, end: Number): ColumnChartBuilder;
+      setStacked(): ColumnChartBuilder;
+      setTitle(chartTitle: string): ColumnChartBuilder;
+      setTitleTextStyle(textStyle: TextStyle): ColumnChartBuilder;
+      setXAxisTextStyle(textStyle: TextStyle): ColumnChartBuilder;
+      setXAxisTitle(title: string): ColumnChartBuilder;
+      setXAxisTitleTextStyle(textStyle: TextStyle): ColumnChartBuilder;
+      setYAxisTextStyle(textStyle: TextStyle): ColumnChartBuilder;
+      setYAxisTitle(title: string): ColumnChartBuilder;
+      setYAxisTitleTextStyle(textStyle: TextStyle): ColumnChartBuilder;
+      useLogScale(): ColumnChartBuilder;
+    }
+
+    /**
+     * An enumeration of the valid data types for columns in a DataTable.
+     */
+    export enum ColumnType { DATE, NUMBER, STRING }
+
+    /**
+     * A user interface control object, that drives the data displayed by a DashboardPanel.
+     * 
+     *  A control can be embedded in a UI application. Controls are user interface widgets (category
+     *  pickers, range sliders, autocompleters, etc.) users interact with in order to drive the data
+     *  managed by a dashboard and the charts that are part of it.
+     *  Controls collect user input and use the information to decide which of the data the
+     *  dashboard is managing should be made available to the charts that are part of it.
+     *  Given a data table, a control will filter out the data that doesn't comply with the
+     *  conditions implied by its current state, and will expose the filtered data table as
+     *  an output.
+     * 
+     *  For more details, see the Gviz
+     *  
+     *  documentation.
+     */
+    export interface Control {
+      getId(): string;
+      getType(): string;
+      setId(id: string): Control;
+    }
+
+    /**
+     * An enumeration of the styles for curves in a chart.
+     */
+    export enum CurveStyle { NORMAL, SMOOTH }
+
+    /**
+     * A dashboard is a visual structure that enables the organization and management
+     *  of multiple charts that share the same underlying data.
+     * 
+     *  Controls are user interface widgets (category pickers, range sliders, autocompleters, etc.)
+     *  users interact with in order to drive the data managed by a dashboard and the charts that
+     *  are part of it. For example, a string filter control is a simple text input field that lets
+     *  the user filter data via string matching. Given a column and matching options, the control
+     *  will filter out the rows that don't match the term that's in the input field.
+     * 
+     *  The Gviz API defines a dashboard as a set of charts and controls bound together. The
+     *  bindings between the different components define the data flow, the state of the
+     *  controls filters views of the data which propagate in the dashboard and are
+     *  eventually visualized with charts. For more details, see the Gviz
+     *  
+     *  documentation.
+     * 
+     *  The dashboard panel has two purposes, one is being a container for the charts and
+     *  controls objects that compose the dashboard, and the other is holding the data and use
+     *  as an interface for binding controls to charts.
+     * 
+     *  Here's an example of creating a dashboard and showing it in a UI app:
+     * 
+     *      function doGet() {
+     *        // Create a data table with some sample data.
+     *        var data = Charts.newDataTable()
+     *          .addColumn(Charts.ColumnType.STRING, "Name")
+     *          .addColumn(Charts.ColumnType.NUMBER, "Age")
+     *          .addRow(["Michael", 18])
+     *          .addRow(["Elisa", 12])
+     *          .addRow(["John", 20])
+     *          .addRow(["Jessica", 25])
+     *          .addRow(["Aaron", 14])
+     *          .addRow(["Margareth", 19])
+     *          .addRow(["Miranda", 22])
+     *          .addRow(["May", 20])
+     *          .build();
+     *     
+     *        var chart = Charts.newBarChart()
+     *          .setTitle("Ages")
+     *          .build();
+     *     
+     *        var control = Charts.newStringFilter()
+     *          .setFilterColumnLabel("Name")
+     *          .build();
+     *     
+     *        // Bind the control to the chart in a dashboard panel.
+     *        var dashboard = Charts.newDashboardPanel()
+     *          .setDataTable(data)
+     *          .bind(control, chart)
+     *          .build();
+     *     
+     *        var uiApp = UiApp.createApplication().setTitle("My Dashboard");
+     *     
+     *        var panel = uiApp.createHorizontalPanel()
+     *          .setVerticalAlignment(UiApp.VerticalAlignment.MIDDLE)
+     *          .setSpacing(50);
+     *     
+     *        panel.add(control);
+     *        panel.add(chart);
+     *        dashboard.add(panel);
+     *        uiApp.add(dashboard);
+     *        return uiApp;
+     *      }
+     */
+    export interface DashboardPanel {
+      add(widget: UI.Widget): DashboardPanel;
+      getId(): string;
+      getType(): string;
+      setId(id: string): DashboardPanel;
+    }
+
+    /**
+     * A builder for a dashboard panel object. For an example of how to use
+     *  DashboardPanelBuilder, refer to DashboardPanel.
+     * 
+     *  For more details, see the Gviz
+     *  
+     *  documentation.
+     */
+    export interface DashboardPanelBuilder {
+      bind(control: Control, chart: Chart, controls: Control[], charts: Chart[]): DashboardPanelBuilder;
+      bind(control: Control, chart: Chart, controls: Control[], charts: Chart[]): DashboardPanelBuilder;
+      build(): DashboardPanel;
+      setDataTable(tableBuilder: DataTableBuilder): DashboardPanelBuilder;
+      setDataTable(source: DataTableSource): DashboardPanelBuilder;
+    }
+
+    /**
+     * A Data Table to be used in charts. A DataTable can come from sources such as Google
+     *  Sheets or specified data-table URLs, or can be filled in by hand. This class intentionally has no
+     *  methods: a DataTable can be passed around, but not manipulated directly.
+     */
+    export interface DataTable {
+    }
+
+    /**
+     * Builder of DataTable objects.  Building a data table consists of first specifying its columns,
+     *  and then adding its rows, one at a time.  Example:
+     * 
+     *      var data = Charts.newDataTable()
+     *          .addColumn(Charts.ColumnType.STRING, "Month")
+     *          .addColumn(Charts.ColumnType.NUMBER, "In Store")
+     *          .addColumn(Charts.ColumnType.NUMBER, "Online")
+     *          .addRow(["January", 10, 1])
+     *          .addRow(["February", 12, 1])
+     *          .addRow(["March", 20, 2])
+     *          .addRow(["April", 25, 3])
+     *          .addRow(["May", 30, 4])
+     *          .build();
+     */
+    export interface DataTableBuilder {
+      addColumn(type: ColumnType, label: string): DataTableBuilder;
+      addRow(values: Object[]): DataTableBuilder;
+      build(): DataTable;
+      setValue(row: Integer, column: Integer, value: Object): DataTableBuilder;
+    }
+
+    /**
+     * Interface for objects that can represent their data as a DataTable.
+     * Implementing classes
+     * 
+     * NameBrief description
+     * 
+     * DataTableA Data Table to be used in charts.
+     * 
+     * RangeAccess and modify spreadsheet ranges.
+     */
+    export interface DataTableSource {
+      getDataTable(): DataTable;
+    }
+
+    /**
+     * A data view definition for visualizing chart data.
+     * 
+     *  Data view definition can be set for charts to visualize a view derived from the given data table
+     *  and not the data table itself. For example if the view definition of a chart states that the view
+     *  columns are [0, 3], only the first and the third columns of the data table will be taken into
+     *  consideration when drawing the chart. See DataViewDefinitionBuilder for an example on how
+     *  to define and use a DataViewDefinition.
+     */
+    export interface DataViewDefinition {
+    }
+
+    /**
+     * Builder for DataViewDefinition objects.
+     * 
+     *  Here's an example of using the builder. The data is imported from a Google spreadsheet.
+     * 
+     *      function doGet() {
+     *        // This example creates two table charts side by side. One uses a data view definition to
+     *        // restrict the number of displayed columns.
+     *        var app = UiApp.createApplication();
+     *        // Get sample data from a spreadsheet.
+     *        var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AF' +
+     *            '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
+     *        
+     *        // Create a chart to display all of the data.
+     *        var originalChart = Charts.newTableChart()
+     *            .setDimensions(600, 500)
+     *            .setDataSourceUrl(dataSourceUrl)
+     *            .build();
+     *          
+     *        // Create another chart to display a subset of the data (only columns 1 and 4).
+     *        var dataViewDefinition = Charts.newDataViewDefinition().setColumns([0, 3]);
+     *        var limitedChart = Charts.newTableChart()
+     *            .setDimensions(200, 500)
+     *            .setDataSourceUrl(dataSourceUrl)
+     *            .setDataViewDefinition(dataViewDefinition)
+     *            .build();
+     *            
+     *        var panel = app.createHorizontalPanel().setSpacing(15);
+     *        panel.add(originalChart).add(limitedChart);
+     *        return app.add(panel);
+     *      }
+     */
+    export interface DataViewDefinitionBuilder {
+      build(): DataViewDefinition;
+      setColumns(columns: Object[]): DataViewDefinitionBuilder;
+    }
+
+    /**
+     * Builder for line charts. For more details, see the 
+     *  Google Charts documentation.
+     * 
+     *  Here is an example that shows how to build a line chart. The data is
+     *  imported from a Google spreadsheet.
+     * 
+     *      function doGet() {
+     *        // Get sample data from a spreadsheet.
+     *        var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AG5' +
+     *            '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=2&headers=-1';
+     *        
+     *        var chartBuilder = Charts.newLineChart()
+     *            .setTitle('Yearly Rainfall')
+     *            .setXAxisTitle('Month')
+     *            .setYAxisTitle('Rainfall (in)')
+     *            .setDimensions(600, 500)
+     *            .setCurveStyle(Charts.CurveStyle.SMOOTH)
+     *            .setPointStyle(Charts.PointStyle.MEDIUM)
+     *            .setDataSourceUrl(dataSourceUrl);
+     *        
+     *        var chart = chartBuilder.build();
+     *        return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface LineChartBuilder {
+      build(): Chart;
+      reverseCategories(): LineChartBuilder;
+      setBackgroundColor(cssValue: string): LineChartBuilder;
+      setColors(cssValues: String[]): LineChartBuilder;
+      setCurveStyle(style: CurveStyle): LineChartBuilder;
+      setDataSourceUrl(url: string): LineChartBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): LineChartBuilder;
+      setDataTable(table: DataTableSource): LineChartBuilder;
+      setDataViewDefinition(dataViewDefinition: DataViewDefinition): LineChartBuilder;
+      setDimensions(width: Integer, height: Integer): LineChartBuilder;
+      setLegendPosition(position: Position): LineChartBuilder;
+      setLegendTextStyle(textStyle: TextStyle): LineChartBuilder;
+      setOption(option: string, value: Object): LineChartBuilder;
+      setPointStyle(style: PointStyle): LineChartBuilder;
+      setRange(start: Number, end: Number): LineChartBuilder;
+      setTitle(chartTitle: string): LineChartBuilder;
+      setTitleTextStyle(textStyle: TextStyle): LineChartBuilder;
+      setXAxisTextStyle(textStyle: TextStyle): LineChartBuilder;
+      setXAxisTitle(title: string): LineChartBuilder;
+      setXAxisTitleTextStyle(textStyle: TextStyle): LineChartBuilder;
+      setYAxisTextStyle(textStyle: TextStyle): LineChartBuilder;
+      setYAxisTitle(title: string): LineChartBuilder;
+      setYAxisTitleTextStyle(textStyle: TextStyle): LineChartBuilder;
+      useLogScale(): LineChartBuilder;
+    }
+
+    /**
+     * An enumeration of how a string value should be matched.
+     *  Matching a string is a boolean operation. Given a string, a match term (string), and a match
+     *  type, the operation will output true in the following cases:
+     * 
+     * If the match type equals EXACT and the match term equals the string.
+     * If the match type equals PREFIX and the match term is a prefix of the string.
+     * If the match type equals ANY and the match term is a substring of the string.
+     * 
+     * This enumeration can be used in by a string filter control to decide which rows to filter out
+     *  of the data table. Given a column to filter on, leave only the rows that match the value
+     *  entered in the filter input box, using one of the above matching types.
+     */
+    export enum MatchType { EXACT, PREFIX, ANY }
+
+    /**
+     * A builder for number range filter controls.
+     * 
+     *  A number range filter is a slider with two thumbs that lets the user select ranges of
+     *  numeric values. Given a column of type number and matching options, this control will
+     *  filter out the rows that don't match the range that was selected.
+     * 
+     *  This example creates a table chart bound to a number range filter:
+     * 
+     *      function doGet() {
+     *        var app = UiApp.createApplication();
+     *        // Get sample data from a spreadsheet.
+     *        var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AF' +
+     *            '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
+     *        var data = SpreadsheetApp.openByUrl(dataSourceUrl).getSheetByName('US_GDP').getRange("A1:F");
+     *            
+     *        var chart = Charts.newTableChart()
+     *            .setDimensions(600, 500)
+     *            .build();
+     *            
+     *        var numberRangeFilter = Charts.newNumberRangeFilter()
+     *            .setFilterColumnLabel("Year")
+     *            .setShowRangeValues(true)
+     *            .setLabel("Restrict year range")
+     *            .build();
+     *        
+     *        var panel = app.createVerticalPanel().setSpacing(10);
+     *        panel.add(numberRangeFilter).add(chart);
+     *        
+     *        // Create a new dashboard panel to bind the filter and chart together.
+     *        var dashboard = Charts.newDashboardPanel()
+     *            .setDataTable(data)
+     *            .bind(numberRangeFilter, chart)
+     *            .build();
+     *            
+     *        dashboard.add(panel);
+     *        app.add(dashboard);
+     *        return app;
+     *      }
+     * 
+     *  documentation
+     */
+    export interface NumberRangeFilterBuilder {
+      build(): Control;
+      setDataTable(tableBuilder: DataTableBuilder): NumberRangeFilterBuilder;
+      setDataTable(table: DataTableSource): NumberRangeFilterBuilder;
+      setFilterColumnIndex(columnIndex: Integer): NumberRangeFilterBuilder;
+      setFilterColumnLabel(columnLabel: string): NumberRangeFilterBuilder;
+      setLabel(label: string): NumberRangeFilterBuilder;
+      setLabelSeparator(labelSeparator: string): NumberRangeFilterBuilder;
+      setLabelStacking(orientation: Orientation): NumberRangeFilterBuilder;
+      setMaxValue(maxValue: Integer): NumberRangeFilterBuilder;
+      setMinValue(minValue: Integer): NumberRangeFilterBuilder;
+      setOrientation(orientation: Orientation): NumberRangeFilterBuilder;
+      setShowRangeValues(showRangeValues: boolean): NumberRangeFilterBuilder;
+      setTicks(ticks: Integer): NumberRangeFilterBuilder;
+    }
+
+    /**
+     * An enumeration of the orientation of an object.
+     */
+    export enum Orientation { HORIZONTAL, VERTICAL }
+
+    /**
+     * An enumeration of how to display selected values in picker widget.
+     */
+    export enum PickerValuesLayout { ASIDE, BELOW, BELOW_WRAPPING, BELOW_STACKED }
+
+    /**
+     * A builder for pie charts. For more details, see the 
+     *  Google Charts documentation.
+     * 
+     *  Here is an example that shows how to build a pie chart. The data is 
+     *  imported from a Google spreadsheet.
+     * 
+     *      function doGet() {
+     *        // Get sample data from a spreadsheet.
+     *        var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AB8' +
+     *            '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=3&headers=-1';
+     *        
+     *        var chartBuilder = Charts.newPieChart()
+     *            .setTitle('World Population by Continent')
+     *            .setDimensions(600, 500)
+     *            .set3D()
+     *            .setDataSourceUrl(dataSourceUrl);
+     *        
+     *        var chart = chartBuilder.build();
+     *        return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface PieChartBuilder {
+      build(): Chart;
+      reverseCategories(): PieChartBuilder;
+      set3D(): PieChartBuilder;
+      setBackgroundColor(cssValue: string): PieChartBuilder;
+      setColors(cssValues: String[]): PieChartBuilder;
+      setDataSourceUrl(url: string): PieChartBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): PieChartBuilder;
+      setDataTable(table: DataTableSource): PieChartBuilder;
+      setDataViewDefinition(dataViewDefinition: DataViewDefinition): PieChartBuilder;
+      setDimensions(width: Integer, height: Integer): PieChartBuilder;
+      setLegendPosition(position: Position): PieChartBuilder;
+      setLegendTextStyle(textStyle: TextStyle): PieChartBuilder;
+      setOption(option: string, value: Object): PieChartBuilder;
+      setTitle(chartTitle: string): PieChartBuilder;
+      setTitleTextStyle(textStyle: TextStyle): PieChartBuilder;
+    }
+
+    /**
+     * An enumeration of the styles of points in a line.
+     */
+    export enum PointStyle { NONE, TINY, MEDIUM, LARGE, HUGE }
+
+    /**
+     * An enumeration of legend positions within a chart.
+     */
+    export enum Position { TOP, RIGHT, BOTTOM, NONE }
+
+    /**
+     * Builder for scatter charts. For more details, see the 
+     *  Google Charts documentation.
+     * 
+     *  Here is an example that shows how to build a scatter chart. The data is
+     *  imported from a Google spreadsheet.
+     * 
+     *      function doGet() {
+     *        // Get sample data from a spreadsheet.
+     *        var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=C1%3AD' +
+     *            '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
+     *        
+     *        var chartBuilder = Charts.newScatterChart()
+     *            .setTitle('Adjusted GDP vs. U.S. Population')
+     *            .setXAxisTitle('U.S. Population (millions)')
+     *            .setYAxisTitle('Adjusted GDP ($ billions)')
+     *            .setDimensions(600, 500)
+     *            .setLegendPosition(Charts.Position.NONE)
+     *            .setDataSourceUrl(dataSourceUrl);
+     *        
+     *        var chart = chartBuilder.build();
+     *        return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface ScatterChartBuilder {
+      build(): Chart;
+      setBackgroundColor(cssValue: string): ScatterChartBuilder;
+      setColors(cssValues: String[]): ScatterChartBuilder;
+      setDataSourceUrl(url: string): ScatterChartBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): ScatterChartBuilder;
+      setDataTable(table: DataTableSource): ScatterChartBuilder;
+      setDataViewDefinition(dataViewDefinition: DataViewDefinition): ScatterChartBuilder;
+      setDimensions(width: Integer, height: Integer): ScatterChartBuilder;
+      setLegendPosition(position: Position): ScatterChartBuilder;
+      setLegendTextStyle(textStyle: TextStyle): ScatterChartBuilder;
+      setOption(option: string, value: Object): ScatterChartBuilder;
+      setPointStyle(style: PointStyle): ScatterChartBuilder;
+      setTitle(chartTitle: string): ScatterChartBuilder;
+      setTitleTextStyle(textStyle: TextStyle): ScatterChartBuilder;
+      setXAxisLogScale(): ScatterChartBuilder;
+      setXAxisRange(start: Number, end: Number): ScatterChartBuilder;
+      setXAxisTextStyle(textStyle: TextStyle): ScatterChartBuilder;
+      setXAxisTitle(title: string): ScatterChartBuilder;
+      setXAxisTitleTextStyle(textStyle: TextStyle): ScatterChartBuilder;
+      setYAxisLogScale(): ScatterChartBuilder;
+      setYAxisRange(start: Number, end: Number): ScatterChartBuilder;
+      setYAxisTextStyle(textStyle: TextStyle): ScatterChartBuilder;
+      setYAxisTitle(title: string): ScatterChartBuilder;
+      setYAxisTitleTextStyle(textStyle: TextStyle): ScatterChartBuilder;
+    }
+
+    /**
+     * A builder for string filter controls.
+     * 
+     *  A string filter is a simple text input field that lets the user filter data via string matching.
+     *  Given a column of type string and matching options, this control will filter out the rows that
+     *  don't match the term that's in the input field.
+     * 
+     *  This example creates a table chart and binds it to a string filter. Using the filter, it is
+     *  possible to change the table chart to display a subset of its data.
+     * 
+     *      function doGet() {
+     *        var app = UiApp.createApplication();
+     *        var sampleData = Charts.newDataTable()
+     *            .addColumn(Charts.ColumnType.STRING, "Month")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Dining")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Total")
+     *            .addRow(["Jan", 60, 520])
+     *            .addRow(["Feb", 50, 430])
+     *            .addRow(["Mar", 53, 440])
+     *            .addRow(["Apr", 70, 410])
+     *            .addRow(["May", 80, 390])
+     *            .addRow(["Jun", 60, 500])
+     *            .addRow(["Jul", 100, 450])
+     *            .addRow(["Aug", 140, 431])
+     *            .addRow(["Sep", 75, 488])
+     *            .addRow(["Oct", 70, 521])
+     *            .addRow(["Nov", 58, 388])
+     *            .addRow(["Dec", 63, 400])
+     *            .build();
+     *            
+     *        var chart = Charts.newTableChart()
+     *            .setDimensions(600, 500)
+     *            .build();
+     *            
+     *        var stringFilter = Charts.newStringFilter()
+     *            .setFilterColumnLabel("Month")
+     *            .setRealtimeTrigger(true)
+     *            .setCaseSensitive(true)
+     *            .setLabel("Filter months shown")
+     *            .build();
+     *        
+     *        var panel = app.createVerticalPanel().setSpacing(10);
+     *        panel.add(stringFilter).add(chart);
+     *        
+     *        // Create a dashboard panel to bind the filter and the chart together.
+     *        var dashboard = Charts.newDashboardPanel()
+     *            .setDataTable(sampleData)
+     *            .bind(stringFilter, chart)
+     *            .build();
+     *            
+     *        dashboard.add(panel);
+     *        app.add(dashboard);
+     *        return app;
+     *      }
+     * 
+     *  documentation
+     */
+    export interface StringFilterBuilder {
+      build(): Control;
+      setCaseSensitive(caseSensitive: boolean): StringFilterBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): StringFilterBuilder;
+      setDataTable(table: DataTableSource): StringFilterBuilder;
+      setFilterColumnIndex(columnIndex: Integer): StringFilterBuilder;
+      setFilterColumnLabel(columnLabel: string): StringFilterBuilder;
+      setLabel(label: string): StringFilterBuilder;
+      setLabelSeparator(labelSeparator: string): StringFilterBuilder;
+      setLabelStacking(orientation: Orientation): StringFilterBuilder;
+      setMatchType(matchType: MatchType): StringFilterBuilder;
+      setRealtimeTrigger(realtimeTrigger: boolean): StringFilterBuilder;
+    }
+
+    /**
+     * A builder for table charts. For more details, see the 
+     *  Google Charts documentation.
+     * 
+     *  Here is an example that shows how to build a table chart. The data is
+     *  imported from a Google spreadsheet.
+     * 
+     *      function doGet() {
+     *        // Get sample data from a spreadsheet.
+     *        var dataSourceUrl = 'https://docs.google.com/spreadsheet/tq?range=A1%3AF' +
+     *            '&key=0Aq4s9w_HxMs7dHpfX05JdmVSb1FpT21sbXd4NVE3UEE&gid=4&headers=-1';
+     *        
+     *        var chartBuilder = Charts.newTableChart()
+     *            .setDimensions(600, 500)
+     *            .enablePaging(20)
+     *            .setDataSourceUrl(dataSourceUrl);
+     *        
+     *        var chart = chartBuilder.build();
+     *        return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface TableChartBuilder {
+      build(): Chart;
+      enablePaging(enablePaging: boolean): TableChartBuilder;
+      enablePaging(pageSize: Integer): TableChartBuilder;
+      enablePaging(pageSize: Integer, startPage: Integer): TableChartBuilder;
+      enableRtlTable(rtlEnabled: boolean): TableChartBuilder;
+      enableSorting(enableSorting: boolean): TableChartBuilder;
+      setDataSourceUrl(url: string): TableChartBuilder;
+      setDataTable(tableBuilder: DataTableBuilder): TableChartBuilder;
+      setDataTable(table: DataTableSource): TableChartBuilder;
+      setDataViewDefinition(dataViewDefinition: DataViewDefinition): TableChartBuilder;
+      setDimensions(width: Integer, height: Integer): TableChartBuilder;
+      setFirstRowNumber(number: Integer): TableChartBuilder;
+      setInitialSortingAscending(column: Integer): TableChartBuilder;
+      setInitialSortingDescending(column: Integer): TableChartBuilder;
+      setOption(option: string, value: Object): TableChartBuilder;
+      showRowNumberColumn(showRowNumber: boolean): TableChartBuilder;
+      useAlternatingRowStyle(alternate: boolean): TableChartBuilder;
+    }
+
+    /**
+     * A text style configuration object. Used in charts options to configure text style for
+     *  elements that accepts it, such as title, horizontal axis, vertical axis, legend and tooltip.
+     * 
+     *      // This example creates a chart specifying different text styles for the title and axes.
+     *      function doGet() {
+     *        var sampleData = Charts.newDataTable()
+     *            .addColumn(Charts.ColumnType.STRING, "Seasons")
+     *            .addColumn(Charts.ColumnType.NUMBER, "Rainy Days")
+     *            .addRow(["Winter", 5])
+     *            .addRow(["Spring", 12])
+     *            .addRow(["Summer", 8])
+     *            .addRow(["Fall", 8])
+     *            .build();
+     *     
+     *        var titleTextStyleBuilder = Charts.newTextStyle()
+     *            .setColor('#0000FF').setFontSize(26).setFontName('Ariel');
+     *        var axisTextStyleBuilder = Charts.newTextStyle()
+     *            .setColor('#3A3A3A').setFontSize(20).setFontName('Ariel');
+     *        var titleTextStyle = titleTextStyleBuilder.build();
+     *        var axisTextStyle = axisTextStyleBuilder.build();
+     *     
+     *        var chart = Charts.newLineChart()
+     *            .setTitleTextStyle(titleTextStyle)
+     *            .setXAxisTitleTextStyle(axisTextStyle)
+     *            .setYAxisTitleTextStyle(axisTextStyle)
+     *            .setTitle('Rainy Days Per Season')
+     *            .setXAxisTitle('Season')
+     *            .setYAxisTitle('Number of Rainy Days')
+     *            .setDataTable(sampleData)
+     *            .build();
+     *     
+     *        return UiApp.createApplication().add(chart);
+     *      }
+     */
+    export interface TextStyle {
+      getColor(): string;
+      getFontName(): string;
+      getFontSize(): Number;
+    }
+
+    /**
+     * A builder used to create TextStyle objects. It allows configuration of the text's
+     *  properties such as name, color, and size.
+     * 
+     *  The following example shows how to create a text style using the builder. For a more complete
+     *  example, refer to the documentation for TextStyle.
+     * 
+     *      // Creates a new text style that uses 26-point, blue, Ariel font.
+     *      var textStyleBuilder = Charts.newTextStyle()
+     *          .setColor('#0000FF').setFontName('Ariel').setFontSize(26);
+     *      var style = textStyleBuilder.build();
+     */
+    export interface TextStyleBuilder {
+      build(): TextStyle;
+      setColor(cssValue: string): TextStyleBuilder;
+      setFontName(fontName: string): TextStyleBuilder;
+      setFontSize(fontSize: Number): TextStyleBuilder;
+    }
+
+  }
+}
+
+declare var Charts: GoogleAppsScript.Charts.Charts;

google-apps-script/google-apps-script.contacts.d.ts

@@ -0,0 +1,294 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Contacts {
+    /**
+     * Address field in a contact.
+     */
+    export interface AddressField {
+      deleteAddressField(): void;
+      getAddress(): string;
+      getLabel(): Object;
+      isPrimary(): boolean;
+      setAddress(address: string): AddressField;
+      setAsPrimary(): AddressField;
+      setLabel(field: Field): AddressField;
+      setLabel(label: string): AddressField;
+    }
+
+    /**
+     * Company field in a Contact.
+     */
+    export interface CompanyField {
+      deleteCompanyField(): void;
+      getCompanyName(): string;
+      getJobTitle(): string;
+      isPrimary(): boolean;
+      setAsPrimary(): CompanyField;
+      setCompanyName(company: string): CompanyField;
+      setJobTitle(title: string): CompanyField;
+    }
+
+    /**
+     * A Contact contains the name, address, and various contact details of a contact.
+     */
+    export interface Contact {
+      addAddress(label: Object, address: string): AddressField;
+      addCompany(company: string, title: string): CompanyField;
+      addCustomField(label: Object, content: Object): CustomField;
+      addDate(label: Object, month: Base.Month, day: Integer, year: Integer): DateField;
+      addEmail(label: Object, address: string): EmailField;
+      addIM(label: Object, address: string): IMField;
+      addPhone(label: Object, number: string): PhoneField;
+      addToGroup(group: ContactGroup): Contact;
+      addUrl(label: Object, url: string): UrlField;
+      deleteContact(): void;
+      getAddresses(): AddressField[];
+      getAddresses(label: Object): AddressField[];
+      getCompanies(): CompanyField[];
+      getContactGroups(): ContactGroup[];
+      getCustomFields(): CustomField[];
+      getCustomFields(label: Object): CustomField[];
+      getDates(): DateField[];
+      getDates(label: Object): DateField[];
+      getEmails(): EmailField[];
+      getEmails(label: Object): EmailField[];
+      getFamilyName(): string;
+      getFullName(): string;
+      getGivenName(): string;
+      getIMs(): IMField[];
+      getIMs(label: Object): IMField[];
+      getId(): string;
+      getInitials(): string;
+      getLastUpdated(): Date;
+      getMaidenName(): string;
+      getMiddleName(): string;
+      getNickname(): string;
+      getNotes(): string;
+      getPhones(): PhoneField[];
+      getPhones(label: Object): PhoneField[];
+      getPrefix(): string;
+      getPrimaryEmail(): string;
+      getShortName(): string;
+      getSuffix(): string;
+      getUrls(): UrlField[];
+      getUrls(label: Object): UrlField[];
+      removeFromGroup(group: ContactGroup): Contact;
+      setFamilyName(familyName: string): Contact;
+      setFullName(fullName: string): Contact;
+      setGivenName(givenName: string): Contact;
+      setInitials(initials: string): Contact;
+      setMaidenName(maidenName: string): Contact;
+      setMiddleName(middleName: string): Contact;
+      setNickname(nickname: string): Contact;
+      setNotes(notes: string): Contact;
+      setPrefix(prefix: string): Contact;
+      setShortName(shortName: string): Contact;
+      setSuffix(suffix: string): Contact;
+      getEmailAddresses(): String[];
+      getHomeAddress(): string;
+      getHomeFax(): string;
+      getHomePhone(): string;
+      getMobilePhone(): string;
+      getPager(): string;
+      getUserDefinedField(key: string): string;
+      getUserDefinedFields(): Object;
+      getWorkAddress(): string;
+      getWorkFax(): string;
+      getWorkPhone(): string;
+      setHomeAddress(addr: string): void;
+      setHomeFax(phone: string): void;
+      setHomePhone(phone: string): void;
+      setMobilePhone(phone: string): void;
+      setPager(phone: string): void;
+      setPrimaryEmail(primaryEmail: string): void;
+      setUserDefinedField(key: string, value: string): void;
+      setUserDefinedFields(o: Object): void;
+      setWorkAddress(addr: string): void;
+      setWorkFax(phone: string): void;
+      setWorkPhone(phone: string): void;
+    }
+
+    /**
+     * A ContactGroup is is a group of contacts.
+     */
+    export interface ContactGroup {
+      addContact(contact: Contact): ContactGroup;
+      deleteGroup(): void;
+      getContacts(): Contact[];
+      getId(): string;
+      getName(): string;
+      isSystemGroup(): boolean;
+      removeContact(contact: Contact): ContactGroup;
+      setName(name: string): ContactGroup;
+      getGroupName(): string;
+      setGroupName(name: string): void;
+    }
+
+    /**
+     * This class allows users to access their own Google Contacts and create, remove, and update
+     *  contacts listed therein.
+     */
+    export interface ContactsApp {
+      ExtendedField: ExtendedField
+      Field: Field
+      Gender: Gender
+      Month: Base.Month
+      Priority: Priority
+      Sensitivity: Sensitivity
+      createContact(givenName: string, familyName: string, email: string): Contact;
+      createContactGroup(name: string): ContactGroup;
+      deleteContact(contact: Contact): void;
+      deleteContactGroup(group: ContactGroup): void;
+      getContact(emailAddress: string): Contact;
+      getContactById(id: string): Contact;
+      getContactGroup(name: string): ContactGroup;
+      getContactGroupById(id: string): ContactGroup;
+      getContactGroups(): ContactGroup[];
+      getContacts(): Contact[];
+      getContactsByAddress(query: string): Contact[];
+      getContactsByAddress(query: string, label: Field): Contact[];
+      getContactsByAddress(query: string, label: string): Contact[];
+      getContactsByCompany(query: string): Contact[];
+      getContactsByCustomField(query: Object, label: ExtendedField): Contact[];
+      getContactsByDate(month: Base.Month, day: Integer, label: Field): Contact[];
+      getContactsByDate(month: Base.Month, day: Integer, year: Integer, label: Field): Contact[];
+      getContactsByDate(month: Base.Month, day: Integer, year: Integer, label: string): Contact[];
+      getContactsByDate(month: Base.Month, day: Integer, label: string): Contact[];
+      getContactsByEmailAddress(query: string): Contact[];
+      getContactsByEmailAddress(query: string, label: Field): Contact[];
+      getContactsByEmailAddress(query: string, label: string): Contact[];
+      getContactsByGroup(group: ContactGroup): Contact[];
+      getContactsByIM(query: string): Contact[];
+      getContactsByIM(query: string, label: Field): Contact[];
+      getContactsByIM(query: string, label: string): Contact[];
+      getContactsByJobTitle(query: string): Contact[];
+      getContactsByName(query: string): Contact[];
+      getContactsByName(query: string, label: Field): Contact[];
+      getContactsByNotes(query: string): Contact[];
+      getContactsByPhone(query: string): Contact[];
+      getContactsByPhone(query: string, label: Field): Contact[];
+      getContactsByPhone(query: string, label: string): Contact[];
+      getContactsByUrl(query: string): Contact[];
+      getContactsByUrl(query: string, label: Field): Contact[];
+      getContactsByUrl(query: string, label: string): Contact[];
+      findByEmailAddress(email: string): Contact;
+      findContactGroup(name: string): ContactGroup;
+      getAllContacts(): Contact[];
+    }
+
+    /**
+     * A custom field in a Contact.
+     */
+    export interface CustomField {
+      deleteCustomField(): void;
+      getLabel(): Object;
+      getValue(): Object;
+      setLabel(field: ExtendedField): CustomField;
+      setLabel(label: string): CustomField;
+      setValue(value: Object): CustomField;
+    }
+
+    /**
+     * A date field in a Contact.
+     */
+    export interface DateField {
+      deleteDateField(): void;
+      getDay(): Integer;
+      getLabel(): Object;
+      getMonth(): Base.Month;
+      getYear(): Integer;
+      setDate(month: Base.Month, day: Integer): DateField;
+      setDate(month: Base.Month, day: Integer, year: Integer): DateField;
+      setLabel(label: Field): DateField;
+      setLabel(label: string): DateField;
+    }
+
+    /**
+     * An email field in a Contact.
+     */
+    export interface EmailField {
+      deleteEmailField(): void;
+      getAddress(): string;
+      getDisplayName(): string;
+      getLabel(): Object;
+      isPrimary(): boolean;
+      setAddress(address: string): EmailField;
+      setAsPrimary(): EmailField;
+      setDisplayName(name: string): EmailField;
+      setLabel(field: Field): EmailField;
+      setLabel(label: string): EmailField;
+    }
+
+    /**
+     * An enum for extended contacts fields.
+     */
+    export enum ExtendedField { HOBBY, MILEAGE, LANGUAGE, GENDER, BILLING_INFORMATION, DIRECTORY_SERVER, SENSITIVITY, PRIORITY, HOME, WORK, USER, OTHER }
+
+    /**
+     * An enum for contacts fields.
+     */
+    export enum Field { FULL_NAME, GIVEN_NAME, MIDDLE_NAME, FAMILY_NAME, MAIDEN_NAME, NICKNAME, SHORT_NAME, INITIALS, PREFIX, SUFFIX, HOME_EMAIL, WORK_EMAIL, BIRTHDAY, ANNIVERSARY, HOME_ADDRESS, WORK_ADDRESS, ASSISTANT_PHONE, CALLBACK_PHONE, MAIN_PHONE, PAGER, HOME_FAX, WORK_FAX, HOME_PHONE, WORK_PHONE, MOBILE_PHONE, GOOGLE_VOICE, NOTES, GOOGLE_TALK, AIM, YAHOO, SKYPE, QQ, MSN, ICQ, JABBER, BLOG, FTP, PROFILE, HOME_PAGE, WORK_WEBSITE, HOME_WEBSITE, JOB_TITLE, COMPANY }
+
+    /**
+     * An enum for contact gender.
+     */
+    export enum Gender { MALE, FEMALE }
+
+    /**
+     * An instant messaging field in a Contact.
+     */
+    export interface IMField {
+      deleteIMField(): void;
+      getAddress(): string;
+      getLabel(): Object;
+      isPrimary(): boolean;
+      setAddress(address: string): IMField;
+      setAsPrimary(): IMField;
+      setLabel(field: Field): IMField;
+      setLabel(label: string): IMField;
+    }
+
+    /**
+     * A phone number field in a Contact.
+     */
+    export interface PhoneField {
+      deletePhoneField(): void;
+      getLabel(): Object;
+      getPhoneNumber(): string;
+      isPrimary(): boolean;
+      setAsPrimary(): PhoneField;
+      setLabel(field: Field): PhoneField;
+      setLabel(label: string): PhoneField;
+      setPhoneNumber(number: string): PhoneField;
+    }
+
+    /**
+     * An enum for contact priority.
+     */
+    export enum Priority { HIGH, LOW, NORMAL }
+
+    /**
+     * An enum for contact sensitivity.
+     */
+    export enum Sensitivity { CONFIDENTIAL, NORMAL, PERSONAL, PRIVATE }
+
+    /**
+     * A URL field in a Contact.
+     */
+    export interface UrlField {
+      deleteUrlField(): void;
+      getAddress(): string;
+      getLabel(): Object;
+      isPrimary(): boolean;
+      setAddress(address: string): UrlField;
+      setAsPrimary(): UrlField;
+      setLabel(field: Field): UrlField;
+      setLabel(label: string): UrlField;
+    }
+
+  }
+}
+
+declare var ContactsApp: GoogleAppsScript.Contacts.ContactsApp;

google-apps-script/google-apps-script.content.d.ts

@@ -0,0 +1,54 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Content {
+    /**
+     * Service for returning text content from a script.
+     * 
+     *  You can serve up text in various forms. For example, publish this script as a web app.
+     * 
+     *      function doGet() {
+     *        return ContentService.createTextOutput("Hello World");
+     *      }
+     */
+    export interface ContentService {
+      MimeType: MimeType
+      createTextOutput(): TextOutput;
+      createTextOutput(content: string): TextOutput;
+    }
+
+    /**
+     * An enum for mime types that can be served from a script.
+     */
+    export enum MimeType { ATOM, CSV, ICAL, JAVASCRIPT, JSON, RSS, TEXT, VCARD, XML }
+
+    /**
+     * A TextOutput object that can be served from a script.
+     *  
+     *  Due to security considerations, scripts cannot directly return text content to a browser.
+     *  Instead, the browser is redirected to googleusercontent.com, which will display it without any
+     *  further sanitization or manipulation.
+     *  
+     *  You can return text content like this:
+     * 
+     *      function doGet() {
+     *        return ContentService.createPlainTextOutput("hello world!");
+     *      }
+     * 
+     * ContentService
+     */
+    export interface TextOutput {
+      append(addedContent: string): TextOutput;
+      clear(): TextOutput;
+      downloadAsFile(filename: string): TextOutput;
+      getContent(): string;
+      getFileName(): string;
+      getMimeType(): MimeType;
+      setContent(content: string): TextOutput;
+      setMimeType(mimeType: MimeType): TextOutput;
+    }
+
+  }
+}
+
+declare var ContentService: GoogleAppsScript.Content.ContentService;

google-apps-script/google-apps-script.drive.d.ts

@@ -0,0 +1,261 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Drive {
+    /**
+     * An enum representing classes of users who can access a file or folder, besides any individual
+     *  users who have been explicitly given access. These properties can be accessed from
+     *  DriveApp.Access.
+     * 
+     *      // Creates a folder that anyone on the Internet can read from and write to. (Domain
+     *      // administrators can prohibit this setting for users of Google Apps for Business, Google Apps
+     *      // for Education, or Google Apps for Your Domain.)
+     *      var folder = DriveApp.createFolder('Shared Folder');
+     *      folder.setSharing(DriveApp.Access.ANYONE, DriveApp.Permission.EDIT);
+     */
+    export enum Access { ANYONE, ANYONE_WITH_LINK, DOMAIN, DOMAIN_WITH_LINK, PRIVATE }
+
+    /**
+     * Allows scripts to create, find, and modify files and folders in Google Drive.
+     * 
+     *      // Log the name of every file in the user's Drive.
+     *      var files = DriveApp.getFiles();
+     *      while (files.hasNext()) {
+     *        var file = files.next();
+     *        Logger.log(file.getName());
+     *      }
+     */
+    export interface DriveApp {
+      Access: Access
+      Permission: Permission
+      addFile(child: File): Folder;
+      addFolder(child: Folder): Folder;
+      continueFileIterator(continuationToken: string): FileIterator;
+      continueFolderIterator(continuationToken: string): FolderIterator;
+      createFile(blob: Base.BlobSource): File;
+      createFile(name: string, content: string): File;
+      createFile(name: string, content: string, mimeType: string): File;
+      createFolder(name: string): Folder;
+      getFileById(id: string): File;
+      getFiles(): FileIterator;
+      getFilesByName(name: string): FileIterator;
+      getFilesByType(mimeType: string): FileIterator;
+      getFolderById(id: string): Folder;
+      getFolders(): FolderIterator;
+      getFoldersByName(name: string): FolderIterator;
+      getRootFolder(): Folder;
+      getStorageLimit(): Integer;
+      getStorageUsed(): Integer;
+      getTrashedFiles(): FileIterator;
+      getTrashedFolders(): FolderIterator;
+      removeFile(child: File): Folder;
+      removeFolder(child: Folder): Folder;
+      searchFiles(params: string): FileIterator;
+      searchFolders(params: string): FolderIterator;
+    }
+
+    /**
+     * A file in Google Drive. Files can be accessed or created from DriveApp.
+     * 
+     *      // Trash every untitled spreadsheet that hasn't been updated in a week.
+     *      var files = DriveApp.getFilesByName('Untitled spreadsheet');
+     *      while (files.hasNext()) {
+     *        var file = files.next();
+     *        if (new Date() - file.getLastUpdated() > 7 * 24 * 60 * 60 * 1000) {
+     *          file.setTrashed(true);
+     *        }
+     *      }
+     */
+    export interface File {
+      addCommenter(emailAddress: string): File;
+      addCommenter(user: Base.User): File;
+      addCommenters(emailAddresses: String[]): File;
+      addEditor(emailAddress: string): File;
+      addEditor(user: Base.User): File;
+      addEditors(emailAddresses: String[]): File;
+      addViewer(emailAddress: string): File;
+      addViewer(user: Base.User): File;
+      addViewers(emailAddresses: String[]): File;
+      getAccess(email: string): Permission;
+      getAccess(user: Base.User): Permission;
+      getAs(contentType: string): Base.Blob;
+      getBlob(): Base.Blob;
+      getDateCreated(): Date;
+      getDescription(): string;
+      getDownloadUrl(): string;
+      getEditors(): User[];
+      getId(): string;
+      getLastUpdated(): Date;
+      getMimeType(): string;
+      getName(): string;
+      getOwner(): User;
+      getParents(): FolderIterator;
+      getSharingAccess(): Access;
+      getSharingPermission(): Permission;
+      getSize(): Integer;
+      getThumbnail(): Base.Blob;
+      getUrl(): string;
+      getViewers(): User[];
+      isShareableByEditors(): boolean;
+      isStarred(): boolean;
+      isTrashed(): boolean;
+      makeCopy(): File;
+      makeCopy(destination: Folder): File;
+      makeCopy(name: string): File;
+      makeCopy(name: string, destination: Folder): File;
+      removeCommenter(emailAddress: string): File;
+      removeCommenter(user: Base.User): File;
+      removeEditor(emailAddress: string): File;
+      removeEditor(user: Base.User): File;
+      removeViewer(emailAddress: string): File;
+      removeViewer(user: Base.User): File;
+      revokePermissions(user: string): File;
+      revokePermissions(user: Base.User): File;
+      setContent(content: string): File;
+      setDescription(description: string): File;
+      setName(name: string): File;
+      setOwner(emailAddress: string): File;
+      setOwner(user: Base.User): File;
+      setShareableByEditors(shareable: boolean): File;
+      setSharing(accessType: Access, permissionType: Permission): File;
+      setStarred(starred: boolean): File;
+      setTrashed(trashed: boolean): File;
+    }
+
+    /**
+     * An iterator that allows scripts to iterate over a potentially large collection of files. File
+     *  iterators can be acccessed from DriveApp or a Folder.
+     * 
+     *      // Log the name of every file in the user's Drive.
+     *      var files = DriveApp.getFiles();
+     *      while (files.hasNext()) {
+     *        var file = files.next();
+     *        Logger.log(file.getName());
+     *      }
+     */
+    export interface FileIterator {
+      getContinuationToken(): string;
+      hasNext(): boolean;
+      next(): File;
+    }
+
+    /**
+     * A folder in Google Drive. Folders can be accessed or created from DriveApp.
+     * 
+     *      // Log the name of every folder in the user's Drive.
+     *      var folders = DriveApp.getFolders();
+     *      while (folders.hasNext()) {
+     *        var folder = folders.next();
+     *        Logger.log(folder.getName());
+     *      }
+     */
+    export interface Folder {
+      addEditor(emailAddress: string): Folder;
+      addEditor(user: Base.User): Folder;
+      addEditors(emailAddresses: String[]): Folder;
+      addFile(child: File): Folder;
+      addFolder(child: Folder): Folder;
+      addViewer(emailAddress: string): Folder;
+      addViewer(user: Base.User): Folder;
+      addViewers(emailAddresses: String[]): Folder;
+      createFile(blob: Base.BlobSource): File;
+      createFile(name: string, content: string): File;
+      createFile(name: string, content: string, mimeType: string): File;
+      createFolder(name: string): Folder;
+      getAccess(email: string): Permission;
+      getAccess(user: Base.User): Permission;
+      getDateCreated(): Date;
+      getDescription(): string;
+      getEditors(): User[];
+      getFiles(): FileIterator;
+      getFilesByName(name: string): FileIterator;
+      getFilesByType(mimeType: string): FileIterator;
+      getFolders(): FolderIterator;
+      getFoldersByName(name: string): FolderIterator;
+      getId(): string;
+      getLastUpdated(): Date;
+      getName(): string;
+      getOwner(): User;
+      getParents(): FolderIterator;
+      getSharingAccess(): Access;
+      getSharingPermission(): Permission;
+      getSize(): Integer;
+      getUrl(): string;
+      getViewers(): User[];
+      isShareableByEditors(): boolean;
+      isStarred(): boolean;
+      isTrashed(): boolean;
+      removeEditor(emailAddress: string): Folder;
+      removeEditor(user: Base.User): Folder;
+      removeFile(child: File): Folder;
+      removeFolder(child: Folder): Folder;
+      removeViewer(emailAddress: string): Folder;
+      removeViewer(user: Base.User): Folder;
+      revokePermissions(user: string): Folder;
+      revokePermissions(user: Base.User): Folder;
+      searchFiles(params: string): FileIterator;
+      searchFolders(params: string): FolderIterator;
+      setDescription(description: string): Folder;
+      setName(name: string): Folder;
+      setOwner(emailAddress: string): Folder;
+      setOwner(user: Base.User): Folder;
+      setShareableByEditors(shareable: boolean): Folder;
+      setSharing(accessType: Access, permissionType: Permission): Folder;
+      setStarred(starred: boolean): Folder;
+      setTrashed(trashed: boolean): Folder;
+    }
+
+    /**
+     * An object that allows scripts to iterate over a potentially large collection of folders. Folder
+     *  iterators can be acccessed from DriveApp, a File, or a Folder.
+     * 
+     *      // Log the name of every folder in the user's Drive.
+     *      var folders = DriveApp.getFolders();
+     *      while (folders.hasNext()) {
+     *        var folder = folders.next();
+     *        Logger.log(folder.getName());
+     *      }
+     */
+    export interface FolderIterator {
+      getContinuationToken(): string;
+      hasNext(): boolean;
+      next(): Folder;
+    }
+
+    /**
+     * An enum representing the permissions granted to users who can access a file or folder, besides
+     *  any individual users who have been explicitly given access. These properties can be accessed from
+     *  DriveApp.Permission.
+     * 
+     *      // Creates a folder that anyone on the Internet can read from and write to. (Domain
+     *      // administrators can prohibit this setting for users of Google Apps for Business, Google Apps
+     *      // for Education, or Google Apps for Your Domain.)
+     *      var folder = DriveApp.createFolder('Shared Folder');
+     *      folder.setSharing(DriveApp.Access.ANYONE, DriveApp.Permission.EDIT);
+     */
+    export enum Permission { VIEW, EDIT, COMMENT, OWNER, NONE }
+
+    /**
+     * A user associated with a file in Google Drive. Users can be accessed from
+     *  File.getEditors(), Folder.getViewers(), and other methods.
+     * 
+     *      // Log the email address of all users who have edit access to a file.
+     *      var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var editors = file.getEditors();
+     *      for (var i = 0; i < editors.length; i++) {
+     *        Logger.log(editors[i].getEmail());
+     *      }
+     */
+    export interface User {
+      getDomain(): string;
+      getEmail(): string;
+      getName(): string;
+      getPhotoUrl(): string;
+      getUserLoginId(): string;
+    }
+
+  }
+}
+
+declare var DriveApp: GoogleAppsScript.Drive.DriveApp;

google-apps-script/google-apps-script.forms.d.ts

@@ -0,0 +1,749 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Forms {
+    /**
+     * An enum representing the supported types of image alignment. Alignment types can be accessed from
+     *  FormApp.Alignment.
+     * 
+     *      // Open a form by ID and add a new image item with alignment
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var img = UrlFetchApp.fetch('https://www.google.com/images/srpr/logo4w.png');
+     *      form.addImageItem()
+     *          .setImage(img)
+     *          .setAlignment(FormApp.Alignment.CENTER);
+     */
+    export enum Alignment { LEFT, CENTER, RIGHT }
+
+    /**
+     * A question item that allows the respondent to select one or more checkboxes, as well as an
+     *  optional "other" field. Items can be accessed or created from a Form.
+     * 
+     *      // Open a form by ID and add a new checkbox item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addCheckboxItem();
+     *      item.setTitle('What condiments would you like on your hot dog?')
+     *          .setChoices([
+     *                item.createChoice('Ketchup'),
+     *                item.createChoice('Mustard'),
+     *                item.createChoice('Relish')
+     *          ])
+     *          .showOtherOption(true);
+     */
+    export interface CheckboxItem {
+      createChoice(value: string): Choice;
+      createResponse(responses: String[]): ItemResponse;
+      duplicate(): CheckboxItem;
+      getChoices(): Choice[];
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      hasOtherOption(): boolean;
+      isRequired(): boolean;
+      setChoiceValues(values: String[]): CheckboxItem;
+      setChoices(choices: Choice[]): CheckboxItem;
+      setHelpText(text: string): CheckboxItem;
+      setRequired(enabled: boolean): CheckboxItem;
+      setTitle(title: string): CheckboxItem;
+      showOtherOption(enabled: boolean): CheckboxItem;
+    }
+
+    /**
+     * A single choice associated with a type of Item that supports choices, like
+     *  CheckboxItem, ListItem, or MultipleChoiceItem.
+     * 
+     *      // Create a new form and add a multiple-choice item.
+     *      var form = FormApp.create('Form Name');
+     *      var item = form.addMultipleChoiceItem();
+     *      item.setTitle('Do you prefer cats or dogs?')
+     *          .setChoices([
+     *              item.createChoice('Cats', FormApp.PageNavigationType.CONTINUE),
+     *              item.createChoice('Dogs', FormApp.PageNavigationType.RESTART)
+     *          ]);
+     *     
+     *      // Add another page because navigation has no effect on the last page.
+     *      form.addPageBreakItem().setTitle('You chose well!');
+     *     
+     *      // Log the navigation types that each choice results in.
+     *      var choices = item.getChoices();
+     *      for (var i = 0; i < choices.length; i++) {
+     *      Logger.log('If the respondent chooses "%s", the form will %s.',
+     *                 choices[i].getValue(),
+     *                 choices[i].getPageNavigationType());
+     *      }
+     */
+    export interface Choice {
+      getGotoPage(): PageBreakItem;
+      getPageNavigationType(): PageNavigationType;
+      getValue(): string;
+    }
+
+    /**
+     * A question item that allows the respondent to indicate a date. Items can be accessed or created
+     *  from a Form.
+     * 
+     *      // Open a form by ID and add a new date item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addDateItem();
+     *      item.setTitle('When were you born?');
+     */
+    export interface DateItem {
+      createResponse(response: Date): ItemResponse;
+      duplicate(): DateItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      includesYear(): boolean;
+      isRequired(): boolean;
+      setHelpText(text: string): DateItem;
+      setIncludesYear(enableYear: boolean): DateItem;
+      setRequired(enabled: boolean): DateItem;
+      setTitle(title: string): DateItem;
+    }
+
+    /**
+     * A question item that allows the respondent to indicate a date and time. Items can be accessed or
+     *  created from a Form.
+     * 
+     *      // Open a form by ID and add a new date-time item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addDateTimeItem();
+     *      item.setTitle('When do you want to meet?');
+     */
+    export interface DateTimeItem {
+      createResponse(response: Date): ItemResponse;
+      duplicate(): DateTimeItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      includesYear(): boolean;
+      isRequired(): boolean;
+      setHelpText(text: string): DateTimeItem;
+      setIncludesYear(enableYear: boolean): DateTimeItem;
+      setRequired(enabled: boolean): DateTimeItem;
+      setTitle(title: string): DateTimeItem;
+    }
+
+    /**
+     * An enum representing the supported types of form-response destinations. All forms, including
+     *  those that do not have a destination set explicitly,
+     *  save
+     *  a copy of responses in the form's response store. Destination types can be accessed from
+     *  FormApp.DestinationType.
+     * 
+     *      // Open a form by ID and create a new spreadsheet.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var ss = SpreadsheetApp.create('Spreadsheet Name');
+     *     
+     *      // Update the form's response destination.
+     *      form.setDestination(FormApp.DestinationType.SPREADSHEET, ss.getId());
+     */
+    export enum DestinationType { SPREADSHEET }
+
+    /**
+     * A question item that allows the respondent to indicate a length of time. Items can be accessed or
+     *  created from a Form.
+     * 
+     *      // Open a form by ID and add a new duration item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addDurationItem();
+     *      item.setTitle('How long can you hold your breath?');
+     */
+    export interface DurationItem {
+      createResponse(hours: Integer, minutes: Integer, seconds: Integer): ItemResponse;
+      duplicate(): DurationItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      isRequired(): boolean;
+      setHelpText(text: string): DurationItem;
+      setRequired(enabled: boolean): DurationItem;
+      setTitle(title: string): DurationItem;
+    }
+
+    /**
+     * A form that contains overall properties (such as title, settings, and where responses are stored)
+     *  and items (which includes question items like checkboxes and layout items like page breaks).
+     *  Forms can be accessed or created from FormApp.
+     * 
+     *      // Open a form by ID and create a new spreadsheet.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var ss = SpreadsheetApp.create('Spreadsheet Name');
+     *     
+     *      // Update form properties via chaining.
+     *      form.setTitle('Form Name')
+     *          .setDescription('Description of form')
+     *          .setConfirmationMessage('Thanks for responding!')
+     *          .setAllowResponseEdits(true)
+     *          .setAcceptingResponses(false);
+     *     
+     *      // Update the form's response destination.
+     *      form.setDestination(FormApp.DestinationType.SPREADSHEET, ss.getId());
+     */
+    export interface Form {
+      addCheckboxItem(): CheckboxItem;
+      addDateItem(): DateItem;
+      addDateTimeItem(): DateTimeItem;
+      addDurationItem(): DurationItem;
+      addEditor(emailAddress: string): Form;
+      addEditor(user: Base.User): Form;
+      addEditors(emailAddresses: String[]): Form;
+      addGridItem(): GridItem;
+      addImageItem(): ImageItem;
+      addListItem(): ListItem;
+      addMultipleChoiceItem(): MultipleChoiceItem;
+      addPageBreakItem(): PageBreakItem;
+      addParagraphTextItem(): ParagraphTextItem;
+      addScaleItem(): ScaleItem;
+      addSectionHeaderItem(): SectionHeaderItem;
+      addTextItem(): TextItem;
+      addTimeItem(): TimeItem;
+      addVideoItem(): VideoItem;
+      canEditResponse(): boolean;
+      collectsEmail(): boolean;
+      createResponse(): FormResponse;
+      deleteAllResponses(): Form;
+      deleteItem(index: Integer): void;
+      deleteItem(item: Item): void;
+      getConfirmationMessage(): string;
+      getCustomClosedFormMessage(): string;
+      getDescription(): string;
+      getDestinationId(): string;
+      getDestinationType(): DestinationType;
+      getEditUrl(): string;
+      getEditors(): Base.User[];
+      getId(): string;
+      getItemById(id: Integer): Item;
+      getItems(): Item[];
+      getItems(itemType: ItemType): Item[];
+      getPublishedUrl(): string;
+      getResponse(responseId: string): FormResponse;
+      getResponses(): FormResponse[];
+      getResponses(timestamp: Date): FormResponse[];
+      getShuffleQuestions(): boolean;
+      getSummaryUrl(): string;
+      getTitle(): string;
+      hasLimitOneResponsePerUser(): boolean;
+      hasProgressBar(): boolean;
+      hasRespondAgainLink(): boolean;
+      isAcceptingResponses(): boolean;
+      isPublishingSummary(): boolean;
+      moveItem(from: Integer, to: Integer): Item;
+      moveItem(item: Item, toIndex: Integer): Item;
+      removeDestination(): Form;
+      removeEditor(emailAddress: string): Form;
+      removeEditor(user: Base.User): Form;
+      requiresLogin(): boolean;
+      setAcceptingResponses(enabled: boolean): Form;
+      setAllowResponseEdits(enabled: boolean): Form;
+      setCollectEmail(collect: boolean): Form;
+      setConfirmationMessage(message: string): Form;
+      setCustomClosedFormMessage(message: string): Form;
+      setDescription(description: string): Form;
+      setDestination(type: DestinationType, id: string): Form;
+      setLimitOneResponsePerUser(enabled: boolean): Form;
+      setProgressBar(enabled: boolean): Form;
+      setPublishingSummary(enabled: boolean): Form;
+      setRequireLogin(requireLogin: boolean): Form;
+      setShowLinkToRespondAgain(enabled: boolean): Form;
+      setShuffleQuestions(shuffle: boolean): Form;
+      setTitle(title: string): Form;
+      shortenFormUrl(url: string): string;
+    }
+
+    /**
+     * Allows a script to open existing Forms or create new ones.
+     * 
+     *      // Open a form by ID.
+     *      var existingForm = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *     
+     *      // Create and open a form.
+     *      var newForm = FormApp.create('Form Name');
+     */
+    export interface FormApp {
+      Alignment: Alignment
+      DestinationType: DestinationType
+      ItemType: ItemType
+      PageNavigationType: PageNavigationType
+      create(title: string): Form;
+      getActiveForm(): Form;
+      getUi(): Base.Ui;
+      openById(id: string): Form;
+      openByUrl(url: string): Form;
+    }
+
+    /**
+     * A response to the form as a whole. Form responses have three main uses: they contain the answers
+     *  submitted by a respondent (see getItemResponses(), they can be used to programmatically
+     *  respond to the form (see withItemResponse(response) and submit()), and they
+     *  can be used as a template to create a URL for the form with pre-filled answers. Form responses
+     *  can be created or accessed from a Form.
+     * 
+     *      // Open a form by ID and log the responses to each question.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var formResponses = form.getResponses();
+     *      for (var i = 0; i < formResponses.length; i++) {
+     *        var formResponse = formResponses[i];
+     *        var itemResponses = formResponse.getItemResponses();
+     *        for (var j = 0; j < itemResponses.length; j++) {
+     *          var itemResponse = itemResponses[j];
+     *          Logger.log('Response #%s to the question "%s" was "%s"',
+     *              (i + 1).toString(),
+     *              itemResponse.getItem().getTitle(),
+     *              itemResponse.getResponse());
+     *        }
+     *      }
+     */
+    export interface FormResponse {
+      getEditResponseUrl(): string;
+      getId(): string;
+      getItemResponses(): ItemResponse[];
+      getRespondentEmail(): string;
+      getResponseForItem(item: Item): ItemResponse;
+      getTimestamp(): Date;
+      submit(): FormResponse;
+      toPrefilledUrl(): string;
+      withItemResponse(response: ItemResponse): FormResponse;
+    }
+
+    /**
+     * A question item, presented as a grid of columns and rows, that allows the respondent to select
+     *  one choice per row from a sequence of radio buttons. Items can be accessed or created from a
+     *  Form.
+     * 
+     *      // Open a form by ID and add a new grid item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addGridItem();
+     *      item.setTitle('Rate your interests')
+     *          .setRows(['Cars', 'Computers', 'Celebrities'])
+     *          .setColumns(['Boring', 'So-so', 'Interesting']);
+     */
+    export interface GridItem {
+      createResponse(responses: String[]): ItemResponse;
+      duplicate(): GridItem;
+      getColumns(): String[];
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getRows(): String[];
+      getTitle(): string;
+      getType(): ItemType;
+      isRequired(): boolean;
+      setColumns(columns: String[]): GridItem;
+      setHelpText(text: string): GridItem;
+      setRequired(enabled: boolean): GridItem;
+      setRows(rows: String[]): GridItem;
+      setTitle(title: string): GridItem;
+    }
+
+    /**
+     * A layout item that displays an image. Items can be accessed or created from a Form.
+     * 
+     *      // Open a form by ID and add a new image item
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var img = UrlFetchApp.fetch('https://www.google.com/images/srpr/logo4w.png');
+     *      form.addImageItem()
+     *          .setTitle('Google')
+     *          .setHelpText('Google Logo') // The help text is the image description
+     *          .setImage(img);
+     */
+    export interface ImageItem {
+      duplicate(): ImageItem;
+      getAlignment(): Alignment;
+      getHelpText(): string;
+      getId(): Integer;
+      getImage(): Base.Blob;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      getWidth(): Integer;
+      setAlignment(alignment: Alignment): ImageItem;
+      setHelpText(text: string): ImageItem;
+      setImage(image: Base.BlobSource): ImageItem;
+      setTitle(title: string): ImageItem;
+      setWidth(width: Integer): ImageItem;
+    }
+
+    /**
+     * A generic form item that contains properties common to all items, such as title and help text.
+     *  Items can be accessed or created from a Form.
+     * 
+     *  To operate on type-specific properties, use getType() to check the item's
+     *  ItemType, then cast the item to the
+     *  appropriate class using a method like asCheckboxItem().
+     * 
+     *      // Create a new form and add a text item.
+     *      var form = FormApp.create('Form Name');
+     *      form.addTextItem();
+     *     
+     *      // Access the text item as a generic item.
+     *      var items = form.getItems();
+     *      var item = items[0];
+     *     
+     *      // Cast the generic item to the text-item class.
+     *      if (item.getType() == 'TEXT') {
+     *        var textItem = item.asTextItem();
+     *        textItem.setRequired(false);
+     *      }
+     */
+    export interface Item {
+      asCheckboxItem(): CheckboxItem;
+      asDateItem(): DateItem;
+      asDateTimeItem(): DateTimeItem;
+      asDurationItem(): DurationItem;
+      asGridItem(): GridItem;
+      asImageItem(): ImageItem;
+      asListItem(): ListItem;
+      asMultipleChoiceItem(): MultipleChoiceItem;
+      asPageBreakItem(): PageBreakItem;
+      asParagraphTextItem(): ParagraphTextItem;
+      asScaleItem(): ScaleItem;
+      asSectionHeaderItem(): SectionHeaderItem;
+      asTextItem(): TextItem;
+      asTimeItem(): TimeItem;
+      asVideoItem(): VideoItem;
+      duplicate(): Item;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      setHelpText(text: string): Item;
+      setTitle(title: string): Item;
+    }
+
+    /**
+     * A response to one question item within a form. Item responses can be accessed from
+     *  FormResponse and created from any Item that asks the respondent to answer a
+     *  question.
+     * 
+     *      // Open a form by ID and log the responses to each question.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var formResponses = form.getResponses();
+     *      for (var i = 0; i < formResponses.length; i++) {
+     *        var formResponse = formResponses[i];
+     *        var itemResponses = formResponse.getItemResponses();
+     *        for (var j = 0; j < itemResponses.length; j++) {
+     *          var itemResponse = itemResponses[j];
+     *          Logger.log('Response #%s to the question "%s" was "%s"',
+     *              (i + 1).toString(),
+     *              itemResponse.getItem().getTitle(),
+     *              itemResponse.getResponse());
+     *        }
+     *      }
+     */
+    export interface ItemResponse {
+      getItem(): Item;
+      getResponse(): Object;
+    }
+
+    /**
+     * An enum representing the supported types of form items. Item types can be accessed from
+     *  FormApp.ItemType.
+     * 
+     *      // Open a form by ID and add a new section header.
+     *      var form = FormApp.create('Form Name');
+     *      var item = form.addSectionHeaderItem();
+     *      item.setTitle('Title of new section');
+     *     
+     *      // Check the item type.
+     *      if (item.getType() == FormApp.ItemType.SECTION_HEADER) {
+     *        item.setHelpText('Description of new section.');
+     *      }
+     */
+    export enum ItemType { CHECKBOX, DATE, DATETIME, DURATION, GRID, IMAGE, LIST, MULTIPLE_CHOICE, PAGE_BREAK, PARAGRAPH_TEXT, SCALE, SECTION_HEADER, TEXT, TIME }
+
+    /**
+     * A question item that allows the respondent to select one choice from a drop-down list. Items can
+     *  be accessed or created from a Form.
+     * 
+     *      // Open a form by ID and add a new list item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addListItem();
+     *      item.setTitle('Do you prefer cats or dogs?')
+     *          .setChoices([
+     *              item.createChoice('Cats'),
+     *              item.createChoice('Dogs')
+     *          ]);
+     */
+    export interface ListItem {
+      createChoice(value: string): Choice;
+      createChoice(value: string, navigationItem: PageBreakItem): Choice;
+      createChoice(value: string, navigationType: PageNavigationType): Choice;
+      createResponse(response: string): ItemResponse;
+      duplicate(): ListItem;
+      getChoices(): Choice[];
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      isRequired(): boolean;
+      setChoiceValues(values: String[]): ListItem;
+      setChoices(choices: Choice[]): ListItem;
+      setHelpText(text: string): ListItem;
+      setRequired(enabled: boolean): ListItem;
+      setTitle(title: string): ListItem;
+    }
+
+    /**
+     * A question item that allows the respondent to select one choice from a list of radio buttons or
+     *  an optional "other" field. Items can be accessed or created from a Form.
+     * 
+     *      // Open a form by ID and add a new multiple choice item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addMultipleChoiceItem();
+     *      item.setTitle('Do you prefer cats or dogs?')
+     *          .setChoices([
+     *              item.createChoice('Cats'),
+     *              item.createChoice('Dogs')
+     *           ])
+     *          .showOtherOption(true);
+     */
+    export interface MultipleChoiceItem {
+      createChoice(value: string): Choice;
+      createChoice(value: string, navigationItem: PageBreakItem): Choice;
+      createChoice(value: string, navigationType: PageNavigationType): Choice;
+      createResponse(response: string): ItemResponse;
+      duplicate(): MultipleChoiceItem;
+      getChoices(): Choice[];
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      hasOtherOption(): boolean;
+      isRequired(): boolean;
+      setChoiceValues(values: String[]): MultipleChoiceItem;
+      setChoices(choices: Choice[]): MultipleChoiceItem;
+      setHelpText(text: string): MultipleChoiceItem;
+      setRequired(enabled: boolean): MultipleChoiceItem;
+      setTitle(title: string): MultipleChoiceItem;
+      showOtherOption(enabled: boolean): MultipleChoiceItem;
+    }
+
+    /**
+     * A layout item that marks the start of a page. Items can be accessed or
+     *  created from a Form.
+     * 
+     *      // Create a form and add three page-break items.
+     *      var form = FormApp.create('Form Name');
+     *      var pageTwo = form.addPageBreakItem().setTitle('Page Two');
+     *      var pageThree = form.addPageBreakItem().setTitle('Page Three');
+     *     
+     *      // Make the first two pages navigate elsewhere upon completion. 
+     *      pageTwo.setGoToPage(pageThree); // At end of page one (start of page two), jump to page three
+     *      pageThree.setGoToPage(FormApp.PageNavigationType.RESTART); // At end of page two, restart form
+     */
+    export interface PageBreakItem {
+      duplicate(): PageBreakItem;
+      getGoToPage(): PageBreakItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getPageNavigationType(): PageNavigationType;
+      getTitle(): string;
+      getType(): ItemType;
+      setGoToPage(goToPageItem: PageBreakItem): PageBreakItem;
+      setGoToPage(navigationType: PageNavigationType): PageBreakItem;
+      setHelpText(text: string): PageBreakItem;
+      setTitle(title: string): PageBreakItem;
+    }
+
+    /**
+     * An enum representing the supported types of page navigation. Page navigation types can be
+     *  accessed from FormApp.PageNavigationType.
+     * 
+     * The page navigation occurs after the respondent completes a page that contains the option, and
+     *  only if the respondent chose that option. If the respondent chose multiple options with
+     *  page-navigation instructions on the same page, only the last navigation option has any effect.
+     *  Page navigation also has no effect on the last page of a form.
+     * Choices that use page navigation cannot be combined in the same item with choices that do not
+     *  use page navigation.
+     * 
+     *      // Create a form and add a new multiple-choice item and a page-break item.
+     *      var form = FormApp.create('Form Name');
+     *      var item = form.addMultipleChoiceItem();
+     *      var pageBreak = form.addPageBreakItem();
+     *     
+     *      // Set some choices with go-to-page logic.
+     *      var rightChoice = item.createChoice('Vanilla', FormApp.PageNavigationType.SUBMIT);
+     *      var wrongChoice = item.createChoice('Chocolate', FormApp.PageNavigationType.RESTART);
+     *     
+     *      // For GO_TO_PAGE, just pass in the page break item. For CONTINUE (normally the default), pass in
+     *      // CONTINUE explicitly because page navigation cannot be mixed with non-navigation choices.
+     *      var iffyChoice = item.createChoice('Peanut', pageBreak);
+     *      var otherChoice = item.createChoice('Strawberry', FormApp.PageNavigationType.CONTINUE);
+     *      item.setChoices([rightChoice, wrongChoice, iffyChoice, otherChoice]);
+     */
+    export enum PageNavigationType { CONTINUE, GO_TO_PAGE, RESTART, SUBMIT }
+
+    /**
+     * A question item that allows the respondent to enter a block of text. Items can be accessed or
+     *  created from a Form.
+     * 
+     *      // Open a form by ID and add a new paragraph text item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addParagraphTextItem();
+     *      item.setTitle('What is your address?');
+     */
+    export interface ParagraphTextItem {
+      createResponse(response: string): ItemResponse;
+      duplicate(): ParagraphTextItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      isRequired(): boolean;
+      setHelpText(text: string): ParagraphTextItem;
+      setRequired(enabled: boolean): ParagraphTextItem;
+      setTitle(title: string): ParagraphTextItem;
+    }
+
+    /**
+     * A question item that allows the respondent to choose one option from a numbered sequence of radio
+     *  buttons. Items can be accessed or created from a Form.
+     * 
+     *      // Open a form by ID and add a new scale item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addScaleItem();
+     *      item.setTitle('Pick a number between 1 and 10')
+     *          .setBounds(1, 10);
+     */
+    export interface ScaleItem {
+      createResponse(response: Integer): ItemResponse;
+      duplicate(): ScaleItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getLeftLabel(): string;
+      getLowerBound(): Integer;
+      getRightLabel(): string;
+      getTitle(): string;
+      getType(): ItemType;
+      getUpperBound(): Integer;
+      isRequired(): boolean;
+      setBounds(lower: Integer, upper: Integer): ScaleItem;
+      setHelpText(text: string): ScaleItem;
+      setLabels(lower: string, upper: string): ScaleItem;
+      setRequired(enabled: boolean): ScaleItem;
+      setTitle(title: string): ScaleItem;
+    }
+
+    /**
+     * A layout item that visually indicates the start of a section. Items can be accessed or created
+     *  from a Form.
+     * 
+     *      // Open a form by ID and add a new section header.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addSectionHeaderItem();
+     *      item.setTitle('Title of new section');
+     */
+    export interface SectionHeaderItem {
+      duplicate(): SectionHeaderItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      setHelpText(text: string): SectionHeaderItem;
+      setTitle(title: string): SectionHeaderItem;
+    }
+
+    /**
+     * A question item that allows the respondent to enter a single line of text. Items can be accessed
+     *  or created from a Form.
+     * 
+     *      // Open a form by ID and add a new text item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addTextItem();
+     *      item.setTitle('What is your name?');
+     */
+    export interface TextItem {
+      createResponse(response: string): ItemResponse;
+      duplicate(): TextItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      isRequired(): boolean;
+      setHelpText(text: string): TextItem;
+      setRequired(enabled: boolean): TextItem;
+      setTitle(title: string): TextItem;
+    }
+
+    /**
+     * A question item that allows the respondent to indicate a time of day. Items can be accessed or
+     *  created from a Form.
+     * 
+     *      // Open a form by ID and add a new time item.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      var item = form.addTimeItem();
+     *      item.setTitle('What time do you usually wake up in the morning?');
+     */
+    export interface TimeItem {
+      createResponse(hour: Integer, minute: Integer): ItemResponse;
+      duplicate(): TimeItem;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      isRequired(): boolean;
+      setHelpText(text: string): TimeItem;
+      setRequired(enabled: boolean): TimeItem;
+      setTitle(title: string): TimeItem;
+    }
+
+    /**
+     * A layout item that displays a video. Items can be accessed or created from a Form.
+     * 
+     *      // Open a form by ID and add three new video items, using a long URL,
+     *      // a short URL, and a video ID.
+     *      var form = FormApp.openById('1234567890abcdefghijklmnopqrstuvwxyz');
+     *      form.addVideoItem()
+     *          .setTitle('Video Title')
+     *          .setHelpText('Video Caption')
+     *          .setVideoUrl('www.youtube.com/watch?v=1234abcdxyz');
+     *     
+     *      form.addVideoItem()
+     *          .setTitle('Video Title')
+     *          .setHelpText('Video Caption')
+     *          .setVideoUrl('youtu.be/1234abcdxyz');
+     *     
+     *      form.addVideoItem()
+     *          .setTitle('Video Title')
+     *          .setHelpText('Video Caption')
+     *          .setVideoUrl('1234abcdxyz');
+     */
+    export interface VideoItem {
+      duplicate(): VideoItem;
+      getAlignment(): Alignment;
+      getHelpText(): string;
+      getId(): Integer;
+      getIndex(): Integer;
+      getTitle(): string;
+      getType(): ItemType;
+      getWidth(): Integer;
+      setAlignment(alignment: Alignment): VideoItem;
+      setHelpText(text: string): VideoItem;
+      setTitle(title: string): VideoItem;
+      setVideoUrl(youtubeUrl: string): VideoItem;
+      setWidth(width: Integer): VideoItem;
+    }
+
+  }
+}
+
+declare var FormApp: GoogleAppsScript.Forms.FormApp;

google-apps-script/google-apps-script.gmail.d.ts

@@ -0,0 +1,200 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Gmail {
+    /**
+     * Provides access to Gmail threads, messages, and labels.
+     */
+    export interface GmailApp {
+      createLabel(name: string): GmailLabel;
+      deleteLabel(label: GmailLabel): GmailApp;
+      getAliases(): String[];
+      getChatThreads(): GmailThread[];
+      getChatThreads(start: Integer, max: Integer): GmailThread[];
+      getDraftMessages(): GmailMessage[];
+      getInboxThreads(): GmailThread[];
+      getInboxThreads(start: Integer, max: Integer): GmailThread[];
+      getInboxUnreadCount(): Integer;
+      getMessageById(id: string): GmailMessage;
+      getMessagesForThread(thread: GmailThread): GmailMessage[];
+      getMessagesForThreads(threads: GmailThread[]): GmailMessage[][];
+      getPriorityInboxThreads(): GmailThread[];
+      getPriorityInboxThreads(start: Integer, max: Integer): GmailThread[];
+      getPriorityInboxUnreadCount(): Integer;
+      getSpamThreads(): GmailThread[];
+      getSpamThreads(start: Integer, max: Integer): GmailThread[];
+      getSpamUnreadCount(): Integer;
+      getStarredThreads(): GmailThread[];
+      getStarredThreads(start: Integer, max: Integer): GmailThread[];
+      getStarredUnreadCount(): Integer;
+      getThreadById(id: string): GmailThread;
+      getTrashThreads(): GmailThread[];
+      getTrashThreads(start: Integer, max: Integer): GmailThread[];
+      getUserLabelByName(name: string): GmailLabel;
+      getUserLabels(): GmailLabel[];
+      markMessageRead(message: GmailMessage): GmailApp;
+      markMessageUnread(message: GmailMessage): GmailApp;
+      markMessagesRead(messages: GmailMessage[]): GmailApp;
+      markMessagesUnread(messages: GmailMessage[]): GmailApp;
+      markThreadImportant(thread: GmailThread): GmailApp;
+      markThreadRead(thread: GmailThread): GmailApp;
+      markThreadUnimportant(thread: GmailThread): GmailApp;
+      markThreadUnread(thread: GmailThread): GmailApp;
+      markThreadsImportant(threads: GmailThread[]): GmailApp;
+      markThreadsRead(threads: GmailThread[]): GmailApp;
+      markThreadsUnimportant(threads: GmailThread[]): GmailApp;
+      markThreadsUnread(threads: GmailThread[]): GmailApp;
+      moveMessageToTrash(message: GmailMessage): GmailApp;
+      moveMessagesToTrash(messages: GmailMessage[]): GmailApp;
+      moveThreadToArchive(thread: GmailThread): GmailApp;
+      moveThreadToInbox(thread: GmailThread): GmailApp;
+      moveThreadToSpam(thread: GmailThread): GmailApp;
+      moveThreadToTrash(thread: GmailThread): GmailApp;
+      moveThreadsToArchive(threads: GmailThread[]): GmailApp;
+      moveThreadsToInbox(threads: GmailThread[]): GmailApp;
+      moveThreadsToSpam(threads: GmailThread[]): GmailApp;
+      moveThreadsToTrash(threads: GmailThread[]): GmailApp;
+      refreshMessage(message: GmailMessage): GmailApp;
+      refreshMessages(messages: GmailMessage[]): GmailApp;
+      refreshThread(thread: GmailThread): GmailApp;
+      refreshThreads(threads: GmailThread[]): GmailApp;
+      search(query: string): GmailThread[];
+      search(query: string, start: Integer, max: Integer): GmailThread[];
+      sendEmail(recipient: string, subject: string, body: string): GmailApp;
+      sendEmail(recipient: string, subject: string, body: string, options: Object): GmailApp;
+      starMessage(message: GmailMessage): GmailApp;
+      starMessages(messages: GmailMessage[]): GmailApp;
+      unstarMessage(message: GmailMessage): GmailApp;
+      unstarMessages(messages: GmailMessage[]): GmailApp;
+    }
+
+    /**
+     * An attachment from Gmail. This is a regular
+     *  Blob except that it has an extra
+     *  getSize() method that is faster than calling getBytes().length and does
+     *  not count against the Gmail read quota.
+     * 
+     *      // Logs information about any attachments in the first 100 inbox threads.
+     *      var threads = GmailApp.getInboxThreads(0, 100);
+     *      var msgs = GmailApp.getMessagesForThreads(threads);
+     *      for (var i = 0 ; i < msgs.length; i++) {
+     *        for (var j = 0; j < msgs[i].length; j++) {
+     *          var attachments = msgs[i][j].getAttachments();
+     *          for (var k = 0; k < attachments.length; k++) {
+     *            Logger.log('Message "%s" contains the attachment "%s" (%s bytes)',
+     *                       msgs[i][j].getSubject(), attachments[k].getName(), attachments[k].getSize());
+     *          }
+     *        }
+     *      }
+     */
+    export interface GmailAttachment {
+      copyBlob(): Base.Blob;
+      getAs(contentType: string): Base.Blob;
+      getBytes(): Byte[];
+      getContentType(): string;
+      getDataAsString(): string;
+      getDataAsString(charset: string): string;
+      getName(): string;
+      getSize(): Integer;
+      isGoogleType(): boolean;
+      setBytes(data: Byte[]): Base.Blob;
+      setContentType(contentType: string): Base.Blob;
+      setContentTypeFromExtension(): Base.Blob;
+      setDataFromString(string: string): Base.Blob;
+      setDataFromString(string: string, charset: string): Base.Blob;
+      setName(name: string): Base.Blob;
+      getAllBlobs(): Base.Blob[];
+    }
+
+    /**
+     * A user-created label in a user's Gmail account.
+     */
+    export interface GmailLabel {
+      addToThread(thread: GmailThread): GmailLabel;
+      addToThreads(threads: GmailThread[]): GmailLabel;
+      deleteLabel(): void;
+      getName(): string;
+      getThreads(): GmailThread[];
+      getThreads(start: Integer, max: Integer): GmailThread[];
+      getUnreadCount(): Integer;
+      removeFromThread(thread: GmailThread): GmailLabel;
+      removeFromThreads(threads: GmailThread[]): GmailLabel;
+    }
+
+    /**
+     * A message in a user's Gmail account.
+     */
+    export interface GmailMessage {
+      forward(recipient: string): GmailMessage;
+      forward(recipient: string, options: Object): GmailMessage;
+      getAttachments(): GmailAttachment[];
+      getBcc(): string;
+      getBody(): string;
+      getCc(): string;
+      getDate(): Date;
+      getFrom(): string;
+      getId(): string;
+      getPlainBody(): string;
+      getRawContent(): string;
+      getReplyTo(): string;
+      getSubject(): string;
+      getThread(): GmailThread;
+      getTo(): string;
+      isDraft(): boolean;
+      isInChats(): boolean;
+      isInInbox(): boolean;
+      isInTrash(): boolean;
+      isStarred(): boolean;
+      isUnread(): boolean;
+      markRead(): GmailMessage;
+      markUnread(): GmailMessage;
+      moveToTrash(): GmailMessage;
+      refresh(): GmailMessage;
+      reply(body: string): GmailMessage;
+      reply(body: string, options: Object): GmailMessage;
+      replyAll(body: string): GmailMessage;
+      replyAll(body: string, options: Object): GmailMessage;
+      star(): GmailMessage;
+      unstar(): GmailMessage;
+    }
+
+    /**
+     * A thread in a user's Gmail account.
+     */
+    export interface GmailThread {
+      addLabel(label: GmailLabel): GmailThread;
+      getFirstMessageSubject(): string;
+      getId(): string;
+      getLabels(): GmailLabel[];
+      getLastMessageDate(): Date;
+      getMessageCount(): Integer;
+      getMessages(): GmailMessage[];
+      getPermalink(): string;
+      hasStarredMessages(): boolean;
+      isImportant(): boolean;
+      isInChats(): boolean;
+      isInInbox(): boolean;
+      isInSpam(): boolean;
+      isInTrash(): boolean;
+      isUnread(): boolean;
+      markImportant(): GmailThread;
+      markRead(): GmailThread;
+      markUnimportant(): GmailThread;
+      markUnread(): GmailThread;
+      moveToArchive(): GmailThread;
+      moveToInbox(): GmailThread;
+      moveToSpam(): GmailThread;
+      moveToTrash(): GmailThread;
+      refresh(): GmailThread;
+      removeLabel(label: GmailLabel): GmailThread;
+      reply(body: string): GmailThread;
+      reply(body: string, options: Object): GmailThread;
+      replyAll(body: string): GmailThread;
+      replyAll(body: string, options: Object): GmailThread;
+    }
+
+  }
+}
+
+declare var GmailApp: GoogleAppsScript.Gmail.GmailApp;

google-apps-script/google-apps-script.groups.d.ts

@@ -0,0 +1,62 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Groups {
+    /**
+     * A group object whose members and those members' roles within the group
+     *  can be queried.
+     * 
+     *  Here's an example which shows the members of a group. Before running it,
+     *  replace the email address of the group with that of one on your domain.
+     * 
+     *        function listGroupMembers() {
+     *          var group = GroupsApp.getGroupByEmail("example@googlegroups.com");
+     *          var s = group.getEmail() + ': ';
+     *          var users = group.getUsers();
+     *          for (var i = 0; i < users.length; i++) {
+     *            var user = users[i];
+     *            s = s + user.getEmail() + ", ";
+     *          }
+     *          Logger.log(s);
+     *        }
+     */
+    export interface Group {
+      getEmail(): string;
+      getRole(email: string): Role;
+      getRole(user: Base.User): Role;
+      getUsers(): Base.User[];
+      hasUser(email: string): boolean;
+      hasUser(user: Base.User): boolean;
+    }
+
+    /**
+     * This class provides access to Google Groups information. It can be used to
+     *  query information such as a group's email address, or the list of groups in
+     *  which the user is a direct member.
+     * 
+     *  Here's an example that shows how many groups the current user is a member of:
+     * 
+     *        var groups = GroupsApp.getGroups();
+     *        Logger.log('You belong to ' + groups.length + ' groups.');
+     */
+    export interface GroupsApp {
+      Role: Role
+      getGroupByEmail(email: string): Group;
+      getGroups(): Group[];
+    }
+
+    /**
+     * Possible roles of a user within a group, such as owner or ordinary member.
+     *  Users subscribed to a group have exactly one role within the context of that
+     *  group.
+     * See also
+     * 
+     * Group.getRole(email)
+     */
+    export enum Role { OWNER, MANAGER, MEMBER, INVITED, PENDING }
+
+  }
+}
+
+declare var GroupsApp: GoogleAppsScript.Groups.GroupsApp;

google-apps-script/google-apps-script.html.d.ts

@@ -0,0 +1,103 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module HTML {
+    /**
+     * An HtmlOutput object that can be served from a script. Due to security considerations,
+     *  scripts cannot directly return HTML to a browser. Instead, they must sanitize it so that it
+     *  cannot perform malicious actions. You can return sanitized HTML like this:
+     * 
+     *      function doGet() {
+     *        return HtmlService.createHtmlOutput('<b>Hello, world!</b>');
+     *      }
+     * 
+     * HtmlOutput
+     * Google Caja
+     * guide to restrictions in HTML service
+     */
+    export interface HtmlOutput {
+      append(addedContent: string): HtmlOutput;
+      appendUntrusted(addedContent: string): HtmlOutput;
+      asTemplate(): HtmlTemplate;
+      clear(): HtmlOutput;
+      getAs(contentType: string): Base.Blob;
+      getBlob(): Base.Blob;
+      getContent(): string;
+      getHeight(): Integer;
+      getTitle(): string;
+      getWidth(): Integer;
+      setContent(content: string): HtmlOutput;
+      setHeight(height: Integer): HtmlOutput;
+      setSandboxMode(mode: SandboxMode): HtmlOutput;
+      setTitle(title: string): HtmlOutput;
+      setWidth(width: Integer): HtmlOutput;
+    }
+
+    /**
+     * Service for returning HTML and other text content from a script.
+     * 
+     * Due to security considerations, scripts cannot directly return content to a browser. Instead,
+     *  they must sanitize the HTML so that it cannot perform malicious actions. See the description of
+     *  HtmlOutput for what limitations this implies on what can be returned.
+     */
+    export interface HtmlService {
+      SandboxMode: SandboxMode
+      createHtmlOutput(): HtmlOutput;
+      createHtmlOutput(blob: Base.BlobSource): HtmlOutput;
+      createHtmlOutput(html: string): HtmlOutput;
+      createHtmlOutputFromFile(filename: string): HtmlOutput;
+      createTemplate(blob: Base.BlobSource): HtmlTemplate;
+      createTemplate(html: string): HtmlTemplate;
+      createTemplateFromFile(filename: string): HtmlTemplate;
+      getUserAgent(): string;
+    }
+
+    /**
+     * A template object for dynamically constructing HTML. For more information, see the
+     *  guide to templates.
+     */
+    export interface HtmlTemplate {
+      evaluate(): HtmlOutput;
+      getCode(): string;
+      getCodeWithComments(): string;
+      getRawContent(): string;
+    }
+
+    /**
+     * An enum representing the sandbox modes that can be used for client-side HtmlService
+     *  scripts. These values can be accessed from HtmlService.SandboxMode, and set by calling
+     *  HtmlOutput.setSandboxMode(mode).
+     * 
+     * To protect users from being served malicious HTML or JavaScript, client-side code served from
+     *  HTML service executes in a security sandbox that imposes restrictions on the code. The method
+     *  HtmlOutput.setSandboxMode(mode) allows script authors to choose between
+     *  different versions of the sandbox. For more information, see the
+     *  guide to restrictions in HTML service.
+     * If a script does not set a sandbox mode, Apps Script uses NATIVE mode as the default.
+     *  Prior to February 2014, the default was EMULATED. The default is subject to change.
+     * The IFRAME mode imposes many fewer restrictions than the other sandbox modes and runs
+     *  fastest, but does not work at all in certain older browsers, including Internet Explorer 9. By
+     *  contrast, EMULATED mode is more likely to work in
+     *  older browsers that do not support ECMAScript 5 strict
+     *  mode, most notably Internet Explorer 9. NATIVE mode is the middle ground. If
+     *  NATIVE mode is set but not supported in the user's browser, the sandbox mode falls back
+     *  to EMULATED mode for that user.
+     * 
+     *      // Serve HTML with a defined sandbox mode (in Apps Script server-side code).
+     *      var output = HtmlService.createHtmlOutput('<b>Hello, world!</b>');
+     *      output.setSandboxMode(HtmlService.SandboxMode.IFRAME);
+     * 
+     * google.script.sandbox.mode
+     * 
+     *      <!-- Read the sandbox mode (in a client-side script). -->
+     *      <script>
+     *        alert(google.script.sandbox.mode);
+     *      </script>
+     */
+    export enum SandboxMode { EMULATED, IFRAME, NATIVE }
+
+  }
+}
+
+declare var HtmlService: GoogleAppsScript.HTML.HtmlService;

google-apps-script/google-apps-script.jdbc.d.ts

@@ -0,0 +1,897 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module JDBC {
+    /**
+     * The JDBC service allows scripts to connect to Google Cloud SQL, MySQL,
+     *  Microsoft SQL Server, and Oracle databases. For more information, see the
+     *  guide to JDBC.
+     */
+    export interface Jdbc {
+      getCloudSqlConnection(url: string): JdbcConnection;
+      getCloudSqlConnection(url: string, info: Object): JdbcConnection;
+      getCloudSqlConnection(url: string, userName: string, password: string): JdbcConnection;
+      getConnection(url: string): JdbcConnection;
+      getConnection(url: string, info: Object): JdbcConnection;
+      getConnection(url: string, userName: string, password: string): JdbcConnection;
+      newDate(milliseconds: Integer): JdbcDate;
+      newTime(milliseconds: Integer): JdbcTime;
+      newTimestamp(milliseconds: Integer): JdbcTimestamp;
+      parseDate(date: string): JdbcDate;
+      parseTime(time: string): JdbcTime;
+      parseTimestamp(timestamp: string): JdbcTimestamp;
+    }
+
+    /**
+     * A JDBC Array. For documentation of this class, see java.sql.Array.
+     */
+    export interface JdbcArray {
+      free(): void;
+      getArray(): Object;
+      getArray(index: Integer, count: Integer): Object;
+      getBaseType(): Integer;
+      getBaseTypeName(): string;
+      getResultSet(): JdbcResultSet;
+      getResultSet(index: Integer, count: Integer): JdbcResultSet;
+    }
+
+    /**
+     * A JDBC Blob. For documentation of this class, see java.sql.Blob.
+     */
+    export interface JdbcBlob {
+      free(): void;
+      getAppsScriptBlob(): Base.Blob;
+      getAs(contentType: string): Base.Blob;
+      getBytes(position: Integer, length: Integer): Byte[];
+      length(): Integer;
+      position(pattern: Byte[], start: Integer): Integer;
+      position(pattern: JdbcBlob, start: Integer): Integer;
+      setBytes(position: Integer, blobSource: Base.BlobSource): Integer;
+      setBytes(position: Integer, blobSource: Base.BlobSource, offset: Integer, length: Integer): Integer;
+      setBytes(position: Integer, bytes: Byte[]): Integer;
+      setBytes(position: Integer, bytes: Byte[], offset: Integer, length: Integer): Integer;
+      truncate(length: Integer): void;
+    }
+
+    /**
+     * A JDBC CallableStatement. For documentation of this class, see
+     *  java.sql.CallableStatement.
+     * See also
+     * 
+     *  CallableStatement
+     */
+    export interface JdbcCallableStatement {
+      addBatch(): void;
+      addBatch(sql: string): void;
+      cancel(): void;
+      clearBatch(): void;
+      clearParameters(): void;
+      clearWarnings(): void;
+      close(): void;
+      execute(): boolean;
+      execute(sql: string): boolean;
+      execute(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): boolean;
+      execute(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): boolean;
+      execute(sql: string, columnNames: String[]): boolean;
+      executeBatch(): Integer[];
+      executeQuery(): JdbcResultSet;
+      executeQuery(sql: string): JdbcResultSet;
+      executeUpdate(): Integer;
+      executeUpdate(sql: string): Integer;
+      executeUpdate(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): Integer;
+      executeUpdate(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): Integer;
+      executeUpdate(sql: string, columnNames: String[]): Integer;
+      getArray(parameterIndex: Integer): JdbcArray;
+      getArray(parameterName: string): JdbcArray;
+      getBigDecimal(parameterIndex: Integer): BigNumber;
+      getBigDecimal(parameterName: string): BigNumber;
+      getBlob(parameterIndex: Integer): JdbcBlob;
+      getBlob(parameterName: string): JdbcBlob;
+      getBoolean(parameterIndex: Integer): boolean;
+      getBoolean(parameterName: string): boolean;
+      getByte(parameterIndex: Integer): Byte;
+      getByte(parameterName: string): Byte;
+      getBytes(parameterIndex: Integer): Byte[];
+      getBytes(parameterName: string): Byte[];
+      getClob(parameterIndex: Integer): JdbcClob;
+      getClob(parameterName: string): JdbcClob;
+      getConnection(): JdbcConnection;
+      getDate(parameterIndex: Integer): JdbcDate;
+      getDate(parameterIndex: Integer, timeZone: string): JdbcDate;
+      getDate(parameterName: string): JdbcDate;
+      getDate(parameterName: string, timeZone: string): JdbcDate;
+      getDouble(parameterIndex: Integer): Number;
+      getDouble(parameterName: string): Number;
+      getFetchDirection(): Integer;
+      getFetchSize(): Integer;
+      getFloat(parameterIndex: Integer): Number;
+      getFloat(parameterName: string): Number;
+      getGeneratedKeys(): JdbcResultSet;
+      getInt(parameterIndex: Integer): Integer;
+      getInt(parameterName: string): Integer;
+      getLong(parameterIndex: Integer): Integer;
+      getLong(parameterName: string): Integer;
+      getMaxFieldSize(): Integer;
+      getMaxRows(): Integer;
+      getMetaData(): JdbcResultSetMetaData;
+      getMoreResults(): boolean;
+      getMoreResults(current: Integer): boolean;
+      getNClob(parameterIndex: Integer): JdbcClob;
+      getNClob(parameterName: string): JdbcClob;
+      getNString(parameterIndex: Integer): string;
+      getNString(parameterName: string): string;
+      getObject(parameterIndex: Integer): Object;
+      getObject(parameterName: string): Object;
+      getParameterMetaData(): JdbcParameterMetaData;
+      getQueryTimeout(): Integer;
+      getRef(parameterIndex: Integer): JdbcRef;
+      getRef(parameterName: string): JdbcRef;
+      getResultSet(): JdbcResultSet;
+      getResultSetConcurrency(): Integer;
+      getResultSetHoldability(): Integer;
+      getResultSetType(): Integer;
+      getRowId(parameterIndex: Integer): JdbcRowId;
+      getRowId(parameterName: string): JdbcRowId;
+      getSQLXML(parameterIndex: Integer): JdbcSQLXML;
+      getSQLXML(parameterName: string): JdbcSQLXML;
+      getShort(parameterIndex: Integer): Integer;
+      getShort(parameterName: string): Integer;
+      getString(parameterIndex: Integer): string;
+      getString(parameterName: string): string;
+      getTime(parameterIndex: Integer): JdbcTime;
+      getTime(parameterIndex: Integer, timeZone: string): JdbcTime;
+      getTime(parameterName: string): JdbcTime;
+      getTime(parameterName: string, timeZone: string): JdbcTime;
+      getTimestamp(parameterIndex: Integer): JdbcTimestamp;
+      getTimestamp(parameterIndex: Integer, timeZone: string): JdbcTimestamp;
+      getTimestamp(parameterName: string): JdbcTimestamp;
+      getTimestamp(parameterName: string, timeZone: string): JdbcTimestamp;
+      getURL(parameterIndex: Integer): string;
+      getURL(parameterName: string): string;
+      getUpdateCount(): Integer;
+      getWarnings(): String[];
+      isClosed(): boolean;
+      isPoolable(): boolean;
+      registerOutParameter(parameterIndex: Integer, sqlType: Integer): void;
+      registerOutParameter(parameterIndex: Integer, sqlType: Integer, scale: Integer): void;
+      registerOutParameter(parameterIndex: Integer, sqlType: Integer, typeName: string): void;
+      registerOutParameter(parameterName: string, sqlType: Integer): void;
+      registerOutParameter(parameterName: string, sqlType: Integer, scale: Integer): void;
+      registerOutParameter(parameterName: string, sqlType: Integer, typeName: string): void;
+      setArray(parameterIndex: Integer, x: JdbcArray): void;
+      setBigDecimal(parameterIndex: Integer, x: BigNumber): void;
+      setBigDecimal(parameterName: string, x: BigNumber): void;
+      setBlob(parameterIndex: Integer, x: JdbcBlob): void;
+      setBlob(parameterName: string, x: JdbcBlob): void;
+      setBoolean(parameterIndex: Integer, x: boolean): void;
+      setBoolean(parameterName: string, x: boolean): void;
+      setByte(parameterIndex: Integer, x: Byte): void;
+      setByte(parameterName: string, x: Byte): void;
+      setBytes(parameterIndex: Integer, x: Byte[]): void;
+      setBytes(parameterName: string, x: Byte[]): void;
+      setClob(parameterIndex: Integer, x: JdbcClob): void;
+      setClob(parameterName: string, x: JdbcClob): void;
+      setCursorName(name: string): void;
+      setDate(parameterIndex: Integer, x: JdbcDate): void;
+      setDate(parameterIndex: Integer, x: JdbcDate, timeZone: string): void;
+      setDate(parameterName: string, x: JdbcDate): void;
+      setDate(parameterName: string, x: JdbcDate, timeZone: string): void;
+      setDouble(parameterIndex: Integer, x: Number): void;
+      setDouble(parameterName: string, x: Number): void;
+      setEscapeProcessing(enable: boolean): void;
+      setFetchDirection(direction: Integer): void;
+      setFetchSize(rows: Integer): void;
+      setFloat(parameterIndex: Integer, x: Number): void;
+      setFloat(parameterName: string, x: Number): void;
+      setInt(parameterIndex: Integer, x: Integer): void;
+      setInt(parameterName: string, x: Integer): void;
+      setLong(parameterIndex: Integer, x: Integer): void;
+      setLong(parameterName: string, x: Integer): void;
+      setMaxFieldSize(max: Integer): void;
+      setMaxRows(max: Integer): void;
+      setNClob(parameterIndex: Integer, x: JdbcClob): void;
+      setNClob(parameterName: string, value: JdbcClob): void;
+      setNString(parameterIndex: Integer, x: string): void;
+      setNString(parameterName: string, value: string): void;
+      setNull(parameterIndex: Integer, sqlType: Integer): void;
+      setNull(parameterIndex: Integer, sqlType: Integer, typeName: string): void;
+      setNull(parameterName: string, sqlType: Integer): void;
+      setNull(parameterName: string, sqlType: Integer, typeName: string): void;
+      setObject(index: Integer, x: Object): void;
+      setObject(parameterIndex: Integer, x: Object, targetSqlType: Integer): void;
+      setObject(parameterIndex: Integer, x: Object, targetSqlType: Integer, scaleOrLength: Integer): void;
+      setObject(parameterName: string, x: Object): void;
+      setObject(parameterName: string, x: Object, targetSqlType: Integer): void;
+      setObject(parameterName: string, x: Object, targetSqlType: Integer, scale: Integer): void;
+      setPoolable(poolable: boolean): void;
+      setQueryTimeout(seconds: Integer): void;
+      setRef(parameterIndex: Integer, x: JdbcRef): void;
+      setRowId(parameterIndex: Integer, x: JdbcRowId): void;
+      setRowId(parameterName: string, x: JdbcRowId): void;
+      setSQLXML(parameterIndex: Integer, x: JdbcSQLXML): void;
+      setSQLXML(parameterName: string, xmlObject: JdbcSQLXML): void;
+      setShort(parameterIndex: Integer, x: Integer): void;
+      setShort(parameterName: string, x: Integer): void;
+      setString(parameterIndex: Integer, x: string): void;
+      setString(parameterName: string, x: string): void;
+      setTime(parameterIndex: Integer, x: JdbcTime): void;
+      setTime(parameterIndex: Integer, x: JdbcTime, timeZone: string): void;
+      setTime(parameterName: string, x: JdbcTime): void;
+      setTime(parameterName: string, x: JdbcTime, timeZone: string): void;
+      setTimestamp(parameterIndex: Integer, x: JdbcTimestamp): void;
+      setTimestamp(parameterIndex: Integer, x: JdbcTimestamp, timeZone: string): void;
+      setTimestamp(parameterName: string, x: JdbcTimestamp): void;
+      setTimestamp(parameterName: string, x: JdbcTimestamp, timeZone: string): void;
+      setURL(parameterIndex: Integer, x: string): void;
+      setURL(parameterName: string, val: string): void;
+      wasNull(): boolean;
+    }
+
+    /**
+     * A JDBC Clob. For documentation of this class, see java.sql.Clob.
+     */
+    export interface JdbcClob {
+      free(): void;
+      getAppsScriptBlob(): Base.Blob;
+      getAs(contentType: string): Base.Blob;
+      getSubString(position: Integer, length: Integer): string;
+      length(): Integer;
+      position(search: JdbcClob, start: Integer): Integer;
+      position(search: string, start: Integer): Integer;
+      setString(position: Integer, blobSource: Base.BlobSource): Integer;
+      setString(position: Integer, blobSource: Base.BlobSource, offset: Integer, len: Integer): Integer;
+      setString(position: Integer, value: string): Integer;
+      setString(position: Integer, value: string, offset: Integer, len: Integer): Integer;
+      truncate(length: Integer): void;
+    }
+
+    /**
+     * A JDBC Connection. For documentation of this class, see java.sql.Connection.
+     */
+    export interface JdbcConnection {
+      clearWarnings(): void;
+      close(): void;
+      commit(): void;
+      createArrayOf(typeName: string, elements: Object[]): JdbcArray;
+      createBlob(): JdbcBlob;
+      createClob(): JdbcClob;
+      createNClob(): JdbcClob;
+      createSQLXML(): JdbcSQLXML;
+      createStatement(): JdbcStatement;
+      createStatement(resultSetType: Integer, resultSetConcurrency: Integer): JdbcStatement;
+      createStatement(resultSetType: Integer, resultSetConcurrency: Integer, resultSetHoldability: Integer): JdbcStatement;
+      createStruct(typeName: string, attributes: Object[]): JdbcStruct;
+      getAutoCommit(): boolean;
+      getCatalog(): string;
+      getHoldability(): Integer;
+      getMetaData(): JdbcDatabaseMetaData;
+      getTransactionIsolation(): Integer;
+      getWarnings(): String[];
+      isClosed(): boolean;
+      isReadOnly(): boolean;
+      isValid(timeout: Integer): boolean;
+      nativeSQL(sql: string): string;
+      prepareCall(sql: string): JdbcCallableStatement;
+      prepareCall(sql: string, resultSetType: Integer, resultSetConcurrency: Integer): JdbcCallableStatement;
+      prepareCall(sql: string, resultSetType: Integer, resultSetConcurrency: Integer, resultSetHoldability: Integer): JdbcCallableStatement;
+      prepareStatement(sql: string): JdbcPreparedStatement;
+      prepareStatement(sql: string, autoGeneratedKeys: Integer): JdbcPreparedStatement;
+      prepareStatement(sql: string, resultSetType: Integer, resultSetConcurrency: Integer): JdbcPreparedStatement;
+      prepareStatement(sql: string, resultSetType: Integer, resultSetConcurrency: Integer, resultSetHoldability: Integer): JdbcPreparedStatement;
+      prepareStatementByIndex(sql: string, indices: Integer[]): JdbcPreparedStatement;
+      prepareStatementByName(sql: string, columnNames: String[]): JdbcPreparedStatement;
+      releaseSavepoint(savepoint: JdbcSavepoint): void;
+      rollback(): void;
+      rollback(savepoint: JdbcSavepoint): void;
+      setAutoCommit(autoCommit: boolean): void;
+      setCatalog(catalog: string): void;
+      setHoldability(holdability: Integer): void;
+      setReadOnly(readOnly: boolean): void;
+      setSavepoint(): JdbcSavepoint;
+      setSavepoint(name: string): JdbcSavepoint;
+      setTransactionIsolation(level: Integer): void;
+    }
+
+    /**
+     * A JDBC DatabaseMetaData. For documentation of this class, see
+     *  java.sql.DatabaseMetaData.
+     */
+    export interface JdbcDatabaseMetaData {
+      allProceduresAreCallable(): boolean;
+      allTablesAreSelectable(): boolean;
+      autoCommitFailureClosesAllResultSets(): boolean;
+      dataDefinitionCausesTransactionCommit(): boolean;
+      dataDefinitionIgnoredInTransactions(): boolean;
+      deletesAreDetected(type: Integer): boolean;
+      doesMaxRowSizeIncludeBlobs(): boolean;
+      getAttributes(catalog: string, schemaPattern: string, typeNamePattern: string, attributeNamePattern: string): JdbcResultSet;
+      getBestRowIdentifier(catalog: string, schema: string, table: string, scope: Integer, nullable: boolean): JdbcResultSet;
+      getCatalogSeparator(): string;
+      getCatalogTerm(): string;
+      getCatalogs(): JdbcResultSet;
+      getClientInfoProperties(): JdbcResultSet;
+      getColumnPrivileges(catalog: string, schema: string, table: string, columnNamePattern: string): JdbcResultSet;
+      getColumns(catalog: string, schemaPattern: string, tableNamePattern: string, columnNamePattern: string): JdbcResultSet;
+      getConnection(): JdbcConnection;
+      getCrossReference(parentCatalog: string, parentSchema: string, parentTable: string, foreignCatalog: string, foreignSchema: string, foreignTable: string): JdbcResultSet;
+      getDatabaseMajorVersion(): Integer;
+      getDatabaseMinorVersion(): Integer;
+      getDatabaseProductName(): string;
+      getDatabaseProductVersion(): string;
+      getDefaultTransactionIsolation(): Integer;
+      getDriverMajorVersion(): Integer;
+      getDriverMinorVersion(): Integer;
+      getDriverName(): string;
+      getDriverVersion(): string;
+      getExportedKeys(catalog: string, schema: string, table: string): JdbcResultSet;
+      getExtraNameCharacters(): string;
+      getFunctionColumns(catalog: string, schemaPattern: string, functionNamePattern: string, columnNamePattern: string): JdbcResultSet;
+      getFunctions(catalog: string, schemaPattern: string, functionNamePattern: string): JdbcResultSet;
+      getIdentifierQuoteString(): string;
+      getImportedKeys(catalog: string, schema: string, table: string): JdbcResultSet;
+      getIndexInfo(catalog: string, schema: string, table: string, unique: boolean, approximate: boolean): JdbcResultSet;
+      getJDBCMajorVersion(): Integer;
+      getJDBCMinorVersion(): Integer;
+      getMaxBinaryLiteralLength(): Integer;
+      getMaxCatalogNameLength(): Integer;
+      getMaxCharLiteralLength(): Integer;
+      getMaxColumnNameLength(): Integer;
+      getMaxColumnsInGroupBy(): Integer;
+      getMaxColumnsInIndex(): Integer;
+      getMaxColumnsInOrderBy(): Integer;
+      getMaxColumnsInSelect(): Integer;
+      getMaxColumnsInTable(): Integer;
+      getMaxConnections(): Integer;
+      getMaxCursorNameLength(): Integer;
+      getMaxIndexLength(): Integer;
+      getMaxProcedureNameLength(): Integer;
+      getMaxRowSize(): Integer;
+      getMaxSchemaNameLength(): Integer;
+      getMaxStatementLength(): Integer;
+      getMaxStatements(): Integer;
+      getMaxTableNameLength(): Integer;
+      getMaxTablesInSelect(): Integer;
+      getMaxUserNameLength(): Integer;
+      getNumericFunctions(): string;
+      getPrimaryKeys(catalog: string, schema: string, table: string): JdbcResultSet;
+      getProcedureColumns(catalog: string, schemaPattern: string, procedureNamePattern: string, columnNamePattern: string): JdbcResultSet;
+      getProcedureTerm(): string;
+      getProcedures(catalog: string, schemaPattern: string, procedureNamePattern: string): JdbcResultSet;
+      getResultSetHoldability(): Integer;
+      getRowIdLifetime(): Integer;
+      getSQLKeywords(): string;
+      getSQLStateType(): Integer;
+      getSchemaTerm(): string;
+      getSchemas(): JdbcResultSet;
+      getSchemas(catalog: string, schemaPattern: string): JdbcResultSet;
+      getSearchStringEscape(): string;
+      getStringFunctions(): string;
+      getSuperTables(catalog: string, schemaPattern: string, tableNamePattern: string): JdbcResultSet;
+      getSuperTypes(catalog: string, schemaPattern: string, typeNamePattern: string): JdbcResultSet;
+      getSystemFunctions(): string;
+      getTablePrivileges(catalog: string, schemaPattern: string, tableNamePattern: string): JdbcResultSet;
+      getTableTypes(): JdbcResultSet;
+      getTables(catalog: string, schemaPattern: string, tableNamePattern: string, types: String[]): JdbcResultSet;
+      getTimeDateFunctions(): string;
+      getTypeInfo(): JdbcResultSet;
+      getUDTs(catalog: string, schemaPattern: string, typeNamePattern: string, types: Integer[]): JdbcResultSet;
+      getURL(): string;
+      getUserName(): string;
+      getVersionColumns(catalog: string, schema: string, table: string): JdbcResultSet;
+      insertsAreDetected(type: Integer): boolean;
+      isCatalogAtStart(): boolean;
+      isReadOnly(): boolean;
+      locatorsUpdateCopy(): boolean;
+      nullPlusNonNullIsNull(): boolean;
+      nullsAreSortedAtEnd(): boolean;
+      nullsAreSortedAtStart(): boolean;
+      nullsAreSortedHigh(): boolean;
+      nullsAreSortedLow(): boolean;
+      othersDeletesAreVisible(type: Integer): boolean;
+      othersInsertsAreVisible(type: Integer): boolean;
+      othersUpdatesAreVisible(type: Integer): boolean;
+      ownDeletesAreVisible(type: Integer): boolean;
+      ownInsertsAreVisible(type: Integer): boolean;
+      ownUpdatesAreVisible(type: Integer): boolean;
+      storesLowerCaseIdentifiers(): boolean;
+      storesLowerCaseQuotedIdentifiers(): boolean;
+      storesMixedCaseIdentifiers(): boolean;
+      storesMixedCaseQuotedIdentifiers(): boolean;
+      storesUpperCaseIdentifiers(): boolean;
+      storesUpperCaseQuotedIdentifiers(): boolean;
+      supportsANSI92EntryLevelSQL(): boolean;
+      supportsANSI92FullSQL(): boolean;
+      supportsANSI92IntermediateSQL(): boolean;
+      supportsAlterTableWithAddColumn(): boolean;
+      supportsAlterTableWithDropColumn(): boolean;
+      supportsBatchUpdates(): boolean;
+      supportsCatalogsInDataManipulation(): boolean;
+      supportsCatalogsInIndexDefinitions(): boolean;
+      supportsCatalogsInPrivilegeDefinitions(): boolean;
+      supportsCatalogsInProcedureCalls(): boolean;
+      supportsCatalogsInTableDefinitions(): boolean;
+      supportsColumnAliasing(): boolean;
+      supportsConvert(): boolean;
+      supportsConvert(fromType: Integer, toType: Integer): boolean;
+      supportsCoreSQLGrammar(): boolean;
+      supportsCorrelatedSubqueries(): boolean;
+      supportsDataDefinitionAndDataManipulationTransactions(): boolean;
+      supportsDataManipulationTransactionsOnly(): boolean;
+      supportsDifferentTableCorrelationNames(): boolean;
+      supportsExpressionsInOrderBy(): boolean;
+      supportsExtendedSQLGrammar(): boolean;
+      supportsFullOuterJoins(): boolean;
+      supportsGetGeneratedKeys(): boolean;
+      supportsGroupBy(): boolean;
+      supportsGroupByBeyondSelect(): boolean;
+      supportsGroupByUnrelated(): boolean;
+      supportsIntegrityEnhancementFacility(): boolean;
+      supportsLikeEscapeClause(): boolean;
+      supportsLimitedOuterJoins(): boolean;
+      supportsMinimumSQLGrammar(): boolean;
+      supportsMixedCaseIdentifiers(): boolean;
+      supportsMixedCaseQuotedIdentifiers(): boolean;
+      supportsMultipleOpenResults(): boolean;
+      supportsMultipleResultSets(): boolean;
+      supportsMultipleTransactions(): boolean;
+      supportsNamedParameters(): boolean;
+      supportsNonNullableColumns(): boolean;
+      supportsOpenCursorsAcrossCommit(): boolean;
+      supportsOpenCursorsAcrossRollback(): boolean;
+      supportsOpenStatementsAcrossCommit(): boolean;
+      supportsOpenStatementsAcrossRollback(): boolean;
+      supportsOrderByUnrelated(): boolean;
+      supportsOuterJoins(): boolean;
+      supportsPositionedDelete(): boolean;
+      supportsPositionedUpdate(): boolean;
+      supportsResultSetConcurrency(type: Integer, concurrency: Integer): boolean;
+      supportsResultSetHoldability(holdability: Integer): boolean;
+      supportsResultSetType(type: Integer): boolean;
+      supportsSavepoints(): boolean;
+      supportsSchemasInDataManipulation(): boolean;
+      supportsSchemasInIndexDefinitions(): boolean;
+      supportsSchemasInPrivilegeDefinitions(): boolean;
+      supportsSchemasInProcedureCalls(): boolean;
+      supportsSchemasInTableDefinitions(): boolean;
+      supportsSelectForUpdate(): boolean;
+      supportsStatementPooling(): boolean;
+      supportsStoredFunctionsUsingCallSyntax(): boolean;
+      supportsStoredProcedures(): boolean;
+      supportsSubqueriesInComparisons(): boolean;
+      supportsSubqueriesInExists(): boolean;
+      supportsSubqueriesInIns(): boolean;
+      supportsSubqueriesInQuantifieds(): boolean;
+      supportsTableCorrelationNames(): boolean;
+      supportsTransactionIsolationLevel(level: Integer): boolean;
+      supportsTransactions(): boolean;
+      supportsUnion(): boolean;
+      supportsUnionAll(): boolean;
+      updatesAreDetected(type: Integer): boolean;
+      usesLocalFilePerTable(): boolean;
+      usesLocalFiles(): boolean;
+    }
+
+    /**
+     * A JDBC Date. For documentation of this class, see java.sql.Date.
+     */
+    export interface JdbcDate {
+      after(when: JdbcDate): boolean;
+      before(when: JdbcDate): boolean;
+      getDate(): Integer;
+      getMonth(): Integer;
+      getTime(): Integer;
+      getYear(): Integer;
+      setDate(date: Integer): void;
+      setMonth(month: Integer): void;
+      setTime(milliseconds: Integer): void;
+      setYear(year: Integer): void;
+    }
+
+    /**
+     * A JDBC ParameterMetaData. For documentation of this class, see
+     *  java.sql.ParameterMetaData.
+     */
+    export interface JdbcParameterMetaData {
+      getParameterClassName(param: Integer): string;
+      getParameterCount(): Integer;
+      getParameterMode(param: Integer): Integer;
+      getParameterType(param: Integer): Integer;
+      getParameterTypeName(param: Integer): string;
+      getPrecision(param: Integer): Integer;
+      getScale(param: Integer): Integer;
+      isNullable(param: Integer): Integer;
+      isSigned(param: Integer): boolean;
+    }
+
+    /**
+     * A JDBC PreparedStatement. For documentation of this class, see
+     *  java.sql.PreparedStatement.
+     */
+    export interface JdbcPreparedStatement {
+      addBatch(): void;
+      addBatch(sql: string): void;
+      cancel(): void;
+      clearBatch(): void;
+      clearParameters(): void;
+      clearWarnings(): void;
+      close(): void;
+      execute(): boolean;
+      execute(sql: string): boolean;
+      execute(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): boolean;
+      execute(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): boolean;
+      execute(sql: string, columnNames: String[]): boolean;
+      executeBatch(): Integer[];
+      executeQuery(): JdbcResultSet;
+      executeQuery(sql: string): JdbcResultSet;
+      executeUpdate(): Integer;
+      executeUpdate(sql: string): Integer;
+      executeUpdate(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): Integer;
+      executeUpdate(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): Integer;
+      executeUpdate(sql: string, columnNames: String[]): Integer;
+      getConnection(): JdbcConnection;
+      getFetchDirection(): Integer;
+      getFetchSize(): Integer;
+      getGeneratedKeys(): JdbcResultSet;
+      getMaxFieldSize(): Integer;
+      getMaxRows(): Integer;
+      getMetaData(): JdbcResultSetMetaData;
+      getMoreResults(): boolean;
+      getMoreResults(current: Integer): boolean;
+      getParameterMetaData(): JdbcParameterMetaData;
+      getQueryTimeout(): Integer;
+      getResultSet(): JdbcResultSet;
+      getResultSetConcurrency(): Integer;
+      getResultSetHoldability(): Integer;
+      getResultSetType(): Integer;
+      getUpdateCount(): Integer;
+      getWarnings(): String[];
+      isClosed(): boolean;
+      isPoolable(): boolean;
+      setArray(parameterIndex: Integer, x: JdbcArray): void;
+      setBigDecimal(parameterIndex: Integer, x: BigNumber): void;
+      setBlob(parameterIndex: Integer, x: JdbcBlob): void;
+      setBoolean(parameterIndex: Integer, x: boolean): void;
+      setByte(parameterIndex: Integer, x: Byte): void;
+      setBytes(parameterIndex: Integer, x: Byte[]): void;
+      setClob(parameterIndex: Integer, x: JdbcClob): void;
+      setCursorName(name: string): void;
+      setDate(parameterIndex: Integer, x: JdbcDate): void;
+      setDate(parameterIndex: Integer, x: JdbcDate, timeZone: string): void;
+      setDouble(parameterIndex: Integer, x: Number): void;
+      setEscapeProcessing(enable: boolean): void;
+      setFetchDirection(direction: Integer): void;
+      setFetchSize(rows: Integer): void;
+      setFloat(parameterIndex: Integer, x: Number): void;
+      setInt(parameterIndex: Integer, x: Integer): void;
+      setLong(parameterIndex: Integer, x: Integer): void;
+      setMaxFieldSize(max: Integer): void;
+      setMaxRows(max: Integer): void;
+      setNClob(parameterIndex: Integer, x: JdbcClob): void;
+      setNString(parameterIndex: Integer, x: string): void;
+      setNull(parameterIndex: Integer, sqlType: Integer): void;
+      setNull(parameterIndex: Integer, sqlType: Integer, typeName: string): void;
+      setObject(index: Integer, x: Object): void;
+      setObject(parameterIndex: Integer, x: Object, targetSqlType: Integer): void;
+      setObject(parameterIndex: Integer, x: Object, targetSqlType: Integer, scaleOrLength: Integer): void;
+      setPoolable(poolable: boolean): void;
+      setQueryTimeout(seconds: Integer): void;
+      setRef(parameterIndex: Integer, x: JdbcRef): void;
+      setRowId(parameterIndex: Integer, x: JdbcRowId): void;
+      setSQLXML(parameterIndex: Integer, x: JdbcSQLXML): void;
+      setShort(parameterIndex: Integer, x: Integer): void;
+      setString(parameterIndex: Integer, x: string): void;
+      setTime(parameterIndex: Integer, x: JdbcTime): void;
+      setTime(parameterIndex: Integer, x: JdbcTime, timeZone: string): void;
+      setTimestamp(parameterIndex: Integer, x: JdbcTimestamp): void;
+      setTimestamp(parameterIndex: Integer, x: JdbcTimestamp, timeZone: string): void;
+      setURL(parameterIndex: Integer, x: string): void;
+    }
+
+    /**
+     * A JDBC Ref. For documentation of this class, see java.sql.Ref.
+     */
+    export interface JdbcRef {
+      getBaseTypeName(): string;
+      getObject(): Object;
+      setObject(object: Object): void;
+    }
+
+    /**
+     * A JDBC ResultSet. For documentation of this class, see java.sql.ResultSet.
+     */
+    export interface JdbcResultSet {
+      absolute(row: Integer): boolean;
+      afterLast(): void;
+      beforeFirst(): void;
+      cancelRowUpdates(): void;
+      clearWarnings(): void;
+      close(): void;
+      deleteRow(): void;
+      findColumn(columnLabel: string): Integer;
+      first(): boolean;
+      getArray(columnIndex: Integer): JdbcArray;
+      getArray(columnLabel: string): JdbcArray;
+      getBigDecimal(columnIndex: Integer): BigNumber;
+      getBigDecimal(columnLabel: string): BigNumber;
+      getBlob(columnIndex: Integer): JdbcBlob;
+      getBlob(columnLabel: string): JdbcBlob;
+      getBoolean(columnIndex: Integer): boolean;
+      getBoolean(columnLabel: string): boolean;
+      getByte(columnIndex: Integer): Byte;
+      getByte(columnLabel: string): Byte;
+      getBytes(columnIndex: Integer): Byte[];
+      getBytes(columnLabel: string): Byte[];
+      getClob(columnIndex: Integer): JdbcClob;
+      getClob(columnLabel: string): JdbcClob;
+      getConcurrency(): Integer;
+      getCursorName(): string;
+      getDate(columnIndex: Integer): JdbcDate;
+      getDate(columnIndex: Integer, timeZone: string): JdbcDate;
+      getDate(columnLabel: string): JdbcDate;
+      getDate(columnLabel: string, timeZone: string): JdbcDate;
+      getDouble(columnIndex: Integer): Number;
+      getDouble(columnLabel: string): Number;
+      getFetchDirection(): Integer;
+      getFetchSize(): Integer;
+      getFloat(columnIndex: Integer): Number;
+      getFloat(columnLabel: string): Number;
+      getHoldability(): Integer;
+      getInt(columnIndex: Integer): Integer;
+      getInt(columnLabel: string): Integer;
+      getLong(columnIndex: Integer): Integer;
+      getLong(columnLabel: string): Integer;
+      getMetaData(): JdbcResultSetMetaData;
+      getNClob(columnIndex: Integer): JdbcClob;
+      getNClob(columnLabel: string): JdbcClob;
+      getNString(columnIndex: Integer): string;
+      getNString(columnLabel: string): string;
+      getObject(columnIndex: Integer): Object;
+      getObject(columnLabel: string): Object;
+      getRef(columnIndex: Integer): JdbcRef;
+      getRef(columnLabel: string): JdbcRef;
+      getRow(): Integer;
+      getRowId(columnIndex: Integer): JdbcRowId;
+      getRowId(columnLabel: string): JdbcRowId;
+      getSQLXML(columnIndex: Integer): JdbcSQLXML;
+      getSQLXML(columnLabel: string): JdbcSQLXML;
+      getShort(columnIndex: Integer): Integer;
+      getShort(columnLabel: string): Integer;
+      getStatement(): JdbcStatement;
+      getString(columnIndex: Integer): string;
+      getString(columnLabel: string): string;
+      getTime(columnIndex: Integer): JdbcTime;
+      getTime(columnIndex: Integer, timeZone: string): JdbcTime;
+      getTime(columnLabel: string): JdbcTime;
+      getTime(columnLabel: string, timeZone: string): JdbcTime;
+      getTimestamp(columnIndex: Integer): JdbcTimestamp;
+      getTimestamp(columnIndex: Integer, timeZone: string): JdbcTimestamp;
+      getTimestamp(columnLabel: string): JdbcTimestamp;
+      getTimestamp(columnLabel: string, timeZone: string): JdbcTimestamp;
+      getType(): Integer;
+      getURL(columnIndex: Integer): string;
+      getURL(columnLabel: string): string;
+      getWarnings(): String[];
+      insertRow(): void;
+      isAfterLast(): boolean;
+      isBeforeFirst(): boolean;
+      isClosed(): boolean;
+      isFirst(): boolean;
+      isLast(): boolean;
+      last(): boolean;
+      moveToCurrentRow(): void;
+      moveToInsertRow(): void;
+      next(): boolean;
+      previous(): boolean;
+      refreshRow(): void;
+      relative(rows: Integer): boolean;
+      rowDeleted(): boolean;
+      rowInserted(): boolean;
+      rowUpdated(): boolean;
+      setFetchDirection(direction: Integer): void;
+      setFetchSize(rows: Integer): void;
+      updateArray(columnIndex: Integer, x: JdbcArray): void;
+      updateArray(columnLabel: string, x: JdbcArray): void;
+      updateBigDecimal(columnIndex: Integer, x: BigNumber): void;
+      updateBigDecimal(columnLabel: string, x: BigNumber): void;
+      updateBlob(columnIndex: Integer, x: JdbcBlob): void;
+      updateBlob(columnLabel: string, x: JdbcBlob): void;
+      updateBoolean(columnIndex: Integer, x: boolean): void;
+      updateBoolean(columnLabel: string, x: boolean): void;
+      updateByte(columnIndex: Integer, x: Byte): void;
+      updateByte(columnLabel: string, x: Byte): void;
+      updateBytes(columnIndex: Integer, x: Byte[]): void;
+      updateBytes(columnLabel: string, x: Byte[]): void;
+      updateClob(columnIndex: Integer, x: JdbcClob): void;
+      updateClob(columnLabel: string, x: JdbcClob): void;
+      updateDate(columnIndex: Integer, x: JdbcDate): void;
+      updateDate(columnLabel: string, x: JdbcDate): void;
+      updateDouble(columnIndex: Integer, x: Number): void;
+      updateDouble(columnLabel: string, x: Number): void;
+      updateFloat(columnIndex: Integer, x: Number): void;
+      updateFloat(columnLabel: string, x: Number): void;
+      updateInt(columnIndex: Integer, x: Integer): void;
+      updateInt(columnLabel: string, x: Integer): void;
+      updateLong(columnIndex: Integer, x: Integer): void;
+      updateLong(columnLabel: string, x: Integer): void;
+      updateNClob(columnIndex: Integer, x: JdbcClob): void;
+      updateNClob(columnLabel: string, x: JdbcClob): void;
+      updateNString(columnIndex: Integer, x: string): void;
+      updateNString(columnLabel: string, x: string): void;
+      updateNull(columnIndex: Integer): void;
+      updateNull(columnLabel: string): void;
+      updateObject(columnIndex: Integer, x: Object): void;
+      updateObject(columnIndex: Integer, x: Object, scaleOrLength: Integer): void;
+      updateObject(columnLabel: string, x: Object): void;
+      updateObject(columnLabel: string, x: Object, scaleOrLength: Integer): void;
+      updateRef(columnIndex: Integer, x: JdbcRef): void;
+      updateRef(columnLabel: string, x: JdbcRef): void;
+      updateRow(): void;
+      updateRowId(columnIndex: Integer, x: JdbcRowId): void;
+      updateRowId(columnLabel: string, x: JdbcRowId): void;
+      updateSQLXML(columnIndex: Integer, x: JdbcSQLXML): void;
+      updateSQLXML(columnLabel: string, x: JdbcSQLXML): void;
+      updateShort(columnIndex: Integer, x: Integer): void;
+      updateShort(columnLabel: string, x: Integer): void;
+      updateString(columnIndex: Integer, x: string): void;
+      updateString(columnLabel: string, x: string): void;
+      updateTime(columnIndex: Integer, x: JdbcTime): void;
+      updateTime(columnLabel: string, x: JdbcTime): void;
+      updateTimestamp(columnIndex: Integer, x: JdbcTimestamp): void;
+      updateTimestamp(columnLabel: string, x: JdbcTimestamp): void;
+      wasNull(): boolean;
+    }
+
+    /**
+     * A JDBC ResultSetMetaData. For documentation of this class, see
+     *  java.sql.ResultSetMetaData.
+     */
+    export interface JdbcResultSetMetaData {
+      getCatalogName(column: Integer): string;
+      getColumnClassName(column: Integer): string;
+      getColumnCount(): Integer;
+      getColumnDisplaySize(column: Integer): Integer;
+      getColumnLabel(column: Integer): string;
+      getColumnName(column: Integer): string;
+      getColumnType(column: Integer): Integer;
+      getColumnTypeName(column: Integer): string;
+      getPrecision(column: Integer): Integer;
+      getScale(column: Integer): Integer;
+      getSchemaName(column: Integer): string;
+      getTableName(column: Integer): string;
+      isAutoIncrement(column: Integer): boolean;
+      isCaseSensitive(column: Integer): boolean;
+      isCurrency(column: Integer): boolean;
+      isDefinitelyWritable(column: Integer): boolean;
+      isNullable(column: Integer): Integer;
+      isReadOnly(column: Integer): boolean;
+      isSearchable(column: Integer): boolean;
+      isSigned(column: Integer): boolean;
+      isWritable(column: Integer): boolean;
+    }
+
+    /**
+     * A JDBC RowId. For documentation of this class, see java.sql.RowId.
+     */
+    export interface JdbcRowId {
+      getBytes(): Byte[];
+    }
+
+    /**
+     * A JDBC SQLXML. For documentation of this class, see java.sql.SQLXML.
+     */
+    export interface JdbcSQLXML {
+      free(): void;
+      getString(): string;
+      setString(value: string): void;
+    }
+
+    /**
+     * A JDBC Savepoint. For documentation of this class, see java.sql.Savepoint.
+     * See also
+     * 
+     * Savepoint
+     */
+    export interface JdbcSavepoint {
+      getSavepointId(): Integer;
+      getSavepointName(): string;
+    }
+
+    /**
+     * A JDBC Statement. For documentation of this class, see java.sql.Statement.
+     */
+    export interface JdbcStatement {
+      addBatch(sql: string): void;
+      cancel(): void;
+      clearBatch(): void;
+      clearWarnings(): void;
+      close(): void;
+      execute(sql: string): boolean;
+      execute(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): boolean;
+      execute(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): boolean;
+      execute(sql: string, columnNames: String[]): boolean;
+      executeBatch(): Integer[];
+      executeQuery(sql: string): JdbcResultSet;
+      executeUpdate(sql: string): Integer;
+      executeUpdate(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): Integer;
+      executeUpdate(sql: string, autoGeneratedKeys: Integer, sql_: string, columnIndexes: Integer[]): Integer;
+      executeUpdate(sql: string, columnNames: String[]): Integer;
+      getConnection(): JdbcConnection;
+      getFetchDirection(): Integer;
+      getFetchSize(): Integer;
+      getGeneratedKeys(): JdbcResultSet;
+      getMaxFieldSize(): Integer;
+      getMaxRows(): Integer;
+      getMoreResults(): boolean;
+      getMoreResults(current: Integer): boolean;
+      getQueryTimeout(): Integer;
+      getResultSet(): JdbcResultSet;
+      getResultSetConcurrency(): Integer;
+      getResultSetHoldability(): Integer;
+      getResultSetType(): Integer;
+      getUpdateCount(): Integer;
+      getWarnings(): String[];
+      isClosed(): boolean;
+      isPoolable(): boolean;
+      setCursorName(name: string): void;
+      setEscapeProcessing(enable: boolean): void;
+      setFetchDirection(direction: Integer): void;
+      setFetchSize(rows: Integer): void;
+      setMaxFieldSize(max: Integer): void;
+      setMaxRows(max: Integer): void;
+      setPoolable(poolable: boolean): void;
+      setQueryTimeout(seconds: Integer): void;
+    }
+
+    /**
+     * A JDBC Struct. For documentation of this class, see java.sql.Struct.
+     */
+    export interface JdbcStruct {
+      getAttributes(): Object[];
+      getSQLTypeName(): string;
+    }
+
+    /**
+     * A JDBC Time. For documentation of this class, see java.sql.Time.
+     */
+    export interface JdbcTime {
+      after(when: JdbcTime): boolean;
+      before(when: JdbcTime): boolean;
+      getHours(): Integer;
+      getMinutes(): Integer;
+      getSeconds(): Integer;
+      getTime(): Integer;
+      setHours(hours: Integer): void;
+      setMinutes(minutes: Integer): void;
+      setSeconds(seconds: Integer): void;
+      setTime(milliseconds: Integer): void;
+    }
+
+    /**
+     * A JDBC Timestamp. For documentation of this class, see java.sql.Timestamp.
+     */
+    export interface JdbcTimestamp {
+      after(when: JdbcTimestamp): boolean;
+      before(when: JdbcTimestamp): boolean;
+      getDate(): Integer;
+      getHours(): Integer;
+      getMinutes(): Integer;
+      getMonth(): Integer;
+      getNanos(): Integer;
+      getSeconds(): Integer;
+      getTime(): Integer;
+      getYear(): Integer;
+      setDate(date: Integer): void;
+      setHours(hours: Integer): void;
+      setMinutes(minutes: Integer): void;
+      setMonth(month: Integer): void;
+      setNanos(nanoseconds: Integer): void;
+      setSeconds(seconds: Integer): void;
+      setTime(milliseconds: Integer): void;
+      setYear(year: Integer): void;
+    }
+
+  }
+}
+
+declare var Jdbc: GoogleAppsScript.JDBC.Jdbc;

google-apps-script/google-apps-script.language.d.ts

@@ -0,0 +1,20 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Language {
+    /**
+     * The Language service provides scripts a way to compute automatic translations of text.
+     * 
+     *      // The code below will write "Esta es una prueba" to the log.
+     *      var spanish = LanguageApp.translate('This is a test', 'en', 'es');
+     *      Logger.log(spanish);
+     */
+    export interface LanguageApp {
+      translate(text: string, sourceLanguage: string, targetLanguage: string): string;
+      translate(text: string, sourceLanguage: string, targetLanguage: string, advancedArgs: Object): string;
+    }
+
+  }
+}
+
+declare var LanguageApp: GoogleAppsScript.Language.LanguageApp;

google-apps-script/google-apps-script.lock.d.ts

@@ -0,0 +1,55 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Lock {
+    /**
+     * A representation of a mutual-exclusion lock.
+     * 
+     *  This class allows scripts to make sure that only one instance of the script is executing a given
+     *  section of code at a time. This is particularly useful for callbacks and triggers, where a user
+     *  action may cause changes to a shared resource and you want to ensure that aren't collisions.
+     * 
+     *  The following examples shows how to use a lock in a form submit handler.
+     * 
+     *      // Generates a unique ticket number for every form submission.
+     *      function onFormSubmit(e) {
+     *        var targetCell = e.range.offset(0, e.range.getNumColumns(), 1, 1);
+     *     
+     *        // Get a script lock, because we're about to modify a shared resource.
+     *        var lock = LockService.getScriptLock();
+     *        // Wait for up to 30 seconds for other processes to finish.
+     *        lock.waitLock(30000);
+     *     
+     *        var ticketNumber = Number(ScriptProperties.getProperty('lastTicketNumber')) + 1;
+     *        ScriptProperties.setProperty('lastTicketNumber', ticketNumber);
+     *     
+     *        // Release the lock so that other processes can continue.
+     *        lock.releaseLock();
+     *     
+     *        targetCell.setValue(ticketNumber);
+     *      }
+     * 
+     * lastTicketNumber
+     * ScriptProperties
+     */
+    export interface Lock {
+      hasLock(): boolean;
+      releaseLock(): void;
+      tryLock(timeoutInMillis: Integer): boolean;
+      waitLock(timeoutInMillis: Integer): void;
+    }
+
+    /**
+     * Prevents concurrent access to sections of code. This can be useful when you have multiple users
+     *  or processes modifying a shared resource and want to prevent collisions.
+     */
+    export interface LockService {
+      getDocumentLock(): Lock;
+      getScriptLock(): Lock;
+      getUserLock(): Lock;
+    }
+
+  }
+}
+
+declare var LockService: GoogleAppsScript.Lock.LockService;

google-apps-script/google-apps-script.mail.d.ts

@@ -0,0 +1,26 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Mail {
+    /**
+     * Sends email.
+     * 
+     * This service allows users to send emails with complete control over the
+     *  content of the email. Unlike GmailApp, MailApp's sole purpose is sending email. MailApp cannot
+     *  access a user's Gmail inbox.
+     * 
+     * Changes to scripts written using GmailApp are more likely to trigger a re-authorization
+     *  request from a user than MailApp scripts.
+     */
+    export interface MailApp {
+      getRemainingDailyQuota(): Integer;
+      sendEmail(message: Object): void;
+      sendEmail(recipient: string, subject: string, body: string): void;
+      sendEmail(recipient: string, subject: string, body: string, options: Object): void;
+      sendEmail(to: string, replyTo: string, subject: string, body: string): void;
+    }
+
+  }
+}
+
+declare var MailApp: GoogleAppsScript.Mail.MailApp;

google-apps-script/google-apps-script.maps.d.ts

@@ -0,0 +1,314 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Maps {
+    /**
+     * An enum representing the types of restrictions to avoid when finding directions.
+     */
+    export enum Avoid { TOLLS, HIGHWAYS }
+
+    /**
+     * An enum representing the named colors available to use in map images.
+     */
+    export enum Color { BLACK, BROWN, GREEN, PURPLE, YELLOW, BLUE, GRAY, ORANGE, RED, WHITE }
+
+    /**
+     * Allows for the retrieval of directions between locations.
+     *  
+     *  The example below shows how you can use this class to get the directions from Times Square to
+     *  Central Park, stopping first at Lincoln Center, plot the locations and path on a map,
+     *  and send the map in an email.
+     * 
+     *      // Get the directions.
+     *      var directions = Maps.newDirectionFinder()
+     *          .setOrigin('Times Square, New York, NY')
+     *          .addWaypoint('Lincoln Center, New York, NY')
+     *          .setDestination('Central Park, New York, NY')
+     *          .setMode(Maps.DirectionFinder.Mode.DRIVING)
+     *          .getDirections();
+     *      var route = directions.routes[0];
+     *     
+     *      // Set up marker styles.
+     *      var markerSize = Maps.StaticMap.MarkerSize.MID;
+     *      var markerColor = Maps.StaticMap.Color.GREEN
+     *      var markerLetterCode = 'A'.charCodeAt();
+     *     
+     *      // Add markers to the map.
+     *      var map = Maps.newStaticMap();
+     *      for (var i = 0; i < route.legs.length; i++) {
+     *        var leg = route.legs[i];
+     *        if (i == 0) {
+     *          // Add a marker for the start location of the first leg only.
+     *          map.setMarkerStyle(markerSize, markerColor, String.fromCharCode(markerLetterCode));
+     *          map.addMarker(leg.start_location.lat, leg.start_location.lng);
+     *          markerLetterCode++;
+     *        }
+     *        map.setMarkerStyle(markerSize, markerColor, String.fromCharCode(markerLetterCode));
+     *        map.addMarker(leg.end_location.lat, leg.end_location.lng);
+     *        markerLetterCode++;
+     *      }
+     *     
+     *      // Add a path for the entire route.
+     *      map.addPath(route.overview_polyline.points);
+     *     
+     *      // Send the map in an email.
+     *      var toAddress = Session.getActiveUser().getEmail();
+     *      MailApp.sendEmail(toAddress, 'Directions', 'Please open: ' + map.getMapUrl(), {
+     *        htmlBody: 'See below.<br/><img src="cid:mapImage">',
+     *        inlineImages: {
+     *          mapImage: Utilities.newBlob(map.getMapImage(), 'image/png')
+     *        }
+     *      });
+     * 
+     * See also
+     * 
+     * Google Directions API
+     */
+    export interface DirectionFinder {
+      addWaypoint(latitude: Number, longitude: Number): DirectionFinder;
+      addWaypoint(address: string): DirectionFinder;
+      clearWaypoints(): DirectionFinder;
+      getDirections(): Object;
+      setAlternatives(useAlternatives: boolean): DirectionFinder;
+      setArrive(time: Date): DirectionFinder;
+      setAvoid(avoid: string): DirectionFinder;
+      setDepart(time: Date): DirectionFinder;
+      setDestination(latitude: Number, longitude: Number): DirectionFinder;
+      setDestination(address: string): DirectionFinder;
+      setLanguage(language: string): DirectionFinder;
+      setMode(mode: string): DirectionFinder;
+      setOptimizeWaypoints(optimizeOrder: boolean): DirectionFinder;
+      setOrigin(latitude: Number, longitude: Number): DirectionFinder;
+      setOrigin(address: string): DirectionFinder;
+      setRegion(region: string): DirectionFinder;
+    }
+
+    /**
+     * A collection of enums used by DirectionFinder.
+     */
+    export interface DirectionFinderEnums {
+      Avoid: Avoid
+      Mode: Mode
+    }
+
+    /**
+     * Allows for the sampling of elevations at particular locations.
+     *  
+     *  The example below shows how you can use this class to determine the highest point along the route
+     *  from Denver to Grand Junction in Colorado, plot it on a map, and save the map to Google Drive.
+     * 
+     *      // Get directions from Denver to Grand Junction.
+     *      var directions = Maps.newDirectionFinder()
+     *          .setOrigin('Denver, CO')
+     *          .setDestination('Grand Junction, CO')
+     *          .setMode(Maps.DirectionFinder.Mode.DRIVING)
+     *          .getDirections();
+     *      var route = directions.routes[0];
+     *     
+     *      // Get elevation samples along the route.
+     *      var numberOfSamples = 30;
+     *      var response = Maps.newElevationSampler()
+     *          .samplePath(route.overview_polyline.points, numberOfSamples)
+     *     
+     *      // Determine highest point.
+     *      var maxElevation = Number.MIN_VALUE;
+     *      var highestPoint = null;
+     *      for (var i = 0; i < response.results.length; i++) {
+     *        var sample = response.results[i];
+     *        if (sample.elevation > maxElevation) {
+     *          maxElevation = sample.elevation;
+     *          highestPoint = sample.location;
+     *        }
+     *      }
+     *     
+     *      // Add the path and marker to a map.
+     *      var map = Maps.newStaticMap()
+     *          .addPath(route.overview_polyline.points)
+     *          .addMarker(highestPoint.lat, highestPoint.lng);
+     *     
+     *      // Save the map to your drive
+     *      DocsList.createFile(Utilities.newBlob(map.getMapImage(), 'image/png', 'map.png'));
+     * 
+     * See also
+     * 
+     * Google Elevation API
+     */
+    export interface ElevationSampler {
+      sampleLocation(latitude: Number, longitude: Number): Object;
+      sampleLocations(points: Number[]): Object;
+      sampleLocations(encodedPolyline: string): Object;
+      samplePath(points: Number[], numSamples: Integer): Object;
+      samplePath(encodedPolyline: string, numSamples: Integer): Object;
+    }
+
+    /**
+     * An enum representing the format of the map image.
+     * See also
+     * 
+     * Google Static Maps API
+     */
+    export enum Format { PNG, PNG8, PNG32, GIF, JPG, JPG_BASELINE }
+
+    /**
+     * Allows for the conversion between an address and geographical coordinates.
+     *  
+     *  The example below shows how you can use this class find the top nine matches for the location
+     *  "Main St" in Colorado, add them to a map, and then embed it in a new Google Doc.
+     * 
+     *      // Find the best matches for "Main St" in Colorado.
+     *      var response = Maps.newGeocoder()
+     *          // The latitudes and longitudes of southwest and northeast corners of Colorado, respectively.
+     *          .setBounds(36.998166, -109.045486, 41.001666,-102.052002)
+     *          .geocode('Main St');
+     *     
+     *      // Create a Google Doc and map.
+     *      var doc = DocumentApp.create('My Map');
+     *      var map = Maps.newStaticMap();
+     *     
+     *      // Add each result to the map and doc.
+     *      for (var i = 0; i < response.results.length && i < 9; i++) {
+     *        var result = response.results[i];
+     *        map.setMarkerStyle(null, null, i + 1);
+     *        map.addMarker(result.geometry.location.lat, result.geometry.location.lng);
+     *        doc.appendListItem(result.formatted_address);
+     *      }
+     *     
+     *      // Add the finished map to the doc.
+     *      doc.appendImage(Utilities.newBlob(map.getMapImage(), 'image/png'));
+     * 
+     * See also
+     * 
+     * Google Geocoding API
+     */
+    export interface Geocoder {
+      geocode(address: string): Object;
+      reverseGeocode(latitude: Number, longitude: Number): Object;
+      reverseGeocode(swLatitude: Number, swLongitude: Number, neLatitude: Number, neLongitude: Number): Object;
+      setBounds(swLatitude: Number, swLongitude: Number, neLatitude: Number, neLongitude: Number): Geocoder;
+      setLanguage(language: string): Geocoder;
+      setRegion(region: string): Geocoder;
+    }
+
+    /**
+     * Allows for direction finding, geocoding, elevation sampling and the creation of static map
+     *  images.
+     */
+    export interface Maps {
+      DirectionFinder: DirectionFinderEnums
+      StaticMap: StaticMapEnums
+      decodePolyline(polyline: string): Number[];
+      encodePolyline(points: Number[]): string;
+      newDirectionFinder(): DirectionFinder;
+      newElevationSampler(): ElevationSampler;
+      newGeocoder(): Geocoder;
+      newStaticMap(): StaticMap;
+      setAuthentication(clientId: string, signingKey: string): void;
+    }
+
+    /**
+     * An enum representing the size of a marker added to a map.
+     * See also
+     * 
+     * Google Static Maps API
+     */
+    export enum MarkerSize { TINY, MID, SMALL }
+
+    /**
+     * An enum representing the mode of travel to use when finding directions.
+     */
+    export enum Mode { DRIVING, WALKING, BICYCLING, TRANSIT }
+
+    /**
+     * Allows for the creation and decoration of static map images.
+     *  
+     *  The example below shows how you can use this class to create a map of New York City's Theatre
+     *  District, including nearby train stations, and display it in a simple web app.
+     * 
+     *      function doGet(event) {
+     *        // Create a map centered on Times Square.
+     *        var map = Maps.newStaticMap()
+     *            .setSize(600, 600)
+     *            .setCenter('Times Square, New York, NY');
+     *     
+     *        // Add markers for the nearbye train stations.
+     *        map.setMarkerStyle(Maps.StaticMap.MarkerSize.MID, Maps.StaticMap.Color.RED, 'T');
+     *        map.addMarker('Grand Central Station, New York, NY');
+     *        map.addMarker('Penn Station, New York, NY');
+     *     
+     *        // Show the boundaries of the Theatre District.
+     *        var corners = [
+     *          '8th Ave & 53rd St, New York, NY',
+     *          '6th Ave & 53rd St, New York, NY',
+     *          '6th Ave & 40th St, New York, NY',
+     *          '8th Ave & 40th St, New York, NY'
+     *        ];
+     *        map.setPathStyle(4, Maps.StaticMap.Color.BLACK, Maps.StaticMap.Color.BLUE);
+     *        map.beginPath();
+     *        for (var i = 0; i < corners.length; i++) {
+     *          map.addAddress(corners[i]);
+     *        }
+     *     
+     *        // Create the user interface and add the map image.
+     *        var app = UiApp.createApplication().setTitle('NYC Theatre District');
+     *        app.add(app.createImage(map.getMapUrl()));
+     *        return app;
+     *      }
+     * 
+     * See also
+     * 
+     * Google Static Maps API
+     */
+    export interface StaticMap {
+      addAddress(address: string): StaticMap;
+      addMarker(latitude: Number, longitude: Number): StaticMap;
+      addMarker(address: string): StaticMap;
+      addPath(points: Number[]): StaticMap;
+      addPath(polyline: string): StaticMap;
+      addPoint(latitude: Number, longitude: Number): StaticMap;
+      addVisible(latitude: Number, longitude: Number): StaticMap;
+      addVisible(address: string): StaticMap;
+      beginPath(): StaticMap;
+      clearMarkers(): StaticMap;
+      clearPaths(): StaticMap;
+      clearVisibles(): StaticMap;
+      endPath(): StaticMap;
+      getAs(contentType: string): Base.Blob;
+      getBlob(): Base.Blob;
+      getMapImage(): Byte[];
+      getMapUrl(): string;
+      setCenter(latitude: Number, longitude: Number): StaticMap;
+      setCenter(address: string): StaticMap;
+      setCustomMarkerStyle(imageUrl: string, useShadow: boolean): StaticMap;
+      setFormat(format: string): StaticMap;
+      setLanguage(language: string): StaticMap;
+      setMapType(mapType: string): StaticMap;
+      setMarkerStyle(size: string, color: string, label: string): StaticMap;
+      setMobile(useMobileTiles: boolean): StaticMap;
+      setPathStyle(weight: Integer, color: string, fillColor: string): StaticMap;
+      setSize(width: Integer, height: Integer): StaticMap;
+      setZoom(zoom: Integer): StaticMap;
+    }
+
+    /**
+     * A collection of enums used by StaticMap.
+     */
+    export interface StaticMapEnums {
+      Color: Color
+      Format: Format
+      MarkerSize: MarkerSize
+      Type: Type
+    }
+
+    /**
+     * An enum representing the type of map to render.
+     * See also
+     * 
+     * Google Static Maps API
+     */
+    export enum Type { ROADMAP, SATELLITE, TERRAIN, HYBRID }
+
+  }
+}
+
+declare var Maps: GoogleAppsScript.Maps.Maps;

google-apps-script/google-apps-script.optimization.d.ts

@@ -0,0 +1,223 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Optimization {
+    /**
+     * Object storing a linear constraint of the form lowerBound ≤ Sum(a(i) x(i)) ≤ upperBound
+     *  where lowerBound and upperBound are constants, a(i) are constant
+     *  coefficients and x(i) are variables (unknowns).
+     * 
+     *  The example below creates one variable x with values between 0 and 5 and
+     *  creates the constraint 0 ≤ 2 * x ≤ 5. This is done by first creating a constraint with
+     *  the lower bound 5 and upper bound 5. Then the coefficient for variable x
+     *  in this constraint is set to 2.
+     * 
+     *       var engine = LinearOptimizationService.createEngine();
+     *       // Create a variable so we can add it to the constraint
+     *       engine.addVariable('x', 0, 5);
+     *       // Create a linear constraint with the bounds 0 and 10
+     *       var constraint = engine.addConstraint(0, 10);
+     *       // Set the coefficient of the variable in the constraint. The constraint is now:
+     *       // 0 <= 2 * x <= 5
+     *       constraint.setCoefficient('x', 2);
+     */
+    export interface LinearOptimizationConstraint {
+      setCoefficient(variableName: string, coefficient: Number): LinearOptimizationConstraint;
+    }
+
+    /**
+     * The engine used to model and solve a linear program. The example below solves the following
+     *  linear program:
+     * 
+     *  Two variables, x and y:
+     *  
+     * 0 ≤ x ≤ 10
+     * 
+     * 0 ≤ y ≤ 5
+     * 
+     *  Constraints:
+     *  
+     * 0 ≤ 2 * x + 5 * y ≤ 10
+     * 
+     * 0 ≤ 10 * x + 3 * y ≤ 20
+     * 
+     *  Objective:
+     *  Maximize x + y
+     * 
+     *      var engine = LinearOptimizationService.createEngine();
+     *     
+     *      // Add variables, constraints and define the objective with addVariable(), addConstraint(), etc
+     *      // Add two variables, 0 <= x <= 10 and 0 <= y <= 5
+     *      engine.addVariable('x', 0, 10);
+     *      engine.addVariable('y', 0, 5);
+     *     
+     *      // Create the constraint: 0 <= 2 * x + 5 * y <= 10
+     *      var constraint = engine.addConstraint(0, 10);
+     *      constraint.setCoefficient('x', 2);
+     *      constraint.setCoefficient('y', 5);
+     *     
+     *      // Create the constraint: 0 <= 10 * x + 3 * y <= 20
+     *      var constraint = engine.addConstraint(0, 20);
+     *      constraint.setCoefficient('x', 10);
+     *      constraint.setCoefficient('y', 3);
+     *     
+     *      // Set the objective to be x + y
+     *      engine.setObjectiveCoefficient('x', 1);
+     *      engine.setObjectiveCoefficient('y', 1);
+     *     
+     *      // Engine should maximize the objective
+     *      engine.setMaximization();
+     *     
+     *      // Solve the linear program
+     *      var solution = engine.solve();
+     *      if (!solution.isValid()) {
+     *        Logger.log('No solution ' + solution.getStatus());
+     *      } else {
+     *        Logger.log('Value of x: ' + solution.getVariableValue('x'));
+     *        Logger.log('Value of y: ' + solution.getVariableValue('y'));
+     *      }
+     */
+    export interface LinearOptimizationEngine {
+      addConstraint(lowerBound: Number, upperBound: Number): LinearOptimizationConstraint;
+      addVariable(name: string, lowerBound: Number, upperBound: Number): LinearOptimizationEngine;
+      addVariable(name: string, lowerBound: Number, upperBound: Number, type: VariableType): LinearOptimizationEngine;
+      setMaximization(): LinearOptimizationEngine;
+      setMinimization(): LinearOptimizationEngine;
+      setObjectiveCoefficient(variableName: string, coefficient: Number): LinearOptimizationEngine;
+      solve(): LinearOptimizationSolution;
+      solve(seconds: Number): LinearOptimizationSolution;
+    }
+
+    /**
+     * The linear optimization service, used to model and solve linear and mixed-integer linear
+     *  programs. The example below solves the following linear program:
+     * 
+     *  Two variables, x and y:
+     *  
+     * 0 ≤ x ≤ 10
+     * 
+     * 0 ≤ y ≤ 5
+     * 
+     *  Constraints:
+     *  
+     * 0 ≤ 2 * x + 5 * y ≤ 10
+     * 
+     * 0 ≤ 10 * x + 3 * y ≤ 20
+     * 
+     *  Objective:
+     *  Maximize x + y
+     * 
+     *      var engine = LinearOptimizationService.createEngine();
+     *     
+     *      // Add variables, constraints and define the objective using addVariable(), addConstraint(), etc.
+     *      // Add two variables, 0 <= x <= 10 and 0 <= y <= 5
+     *      engine.addVariable('x', 0, 10);
+     *      engine.addVariable('y', 0, 5);
+     *     
+     *      // Create the constraint: 0 <= 2 * x + 5 * y <= 10
+     *      var constraint = engine.addConstraint(0, 10);
+     *      constraint.setCoefficient('x', 2);
+     *      constraint.setCoefficient('y', 5);
+     *     
+     *      // Create the constraint: 0 <= 10 * x + 3 * y <= 20
+     *      var constraint = engine.addConstraint(0, 20);
+     *      constraint.setCoefficient('x', 10);
+     *      constraint.setCoefficient('y', 3);
+     *     
+     *      // Set the objective to be x + y
+     *      engine.setObjectiveCoefficient('x', 1);
+     *      engine.setObjectiveCoefficient('y', 1);
+     *     
+     *      // Engine should maximize the objective.
+     *      engine.setMaximization();
+     *     
+     *      // Solve the linear program
+     *      var solution = engine.solve();
+     *      if (!solution.isValid()) {
+     *        Logger.log('No solution ' + solution.getStatus());
+     *      } else {
+     *        Logger.log('Value of x: ' + solution.getVariableValue('x'));
+     *        Logger.log('Value of y: ' + solution.getVariableValue('y'));
+     *      }
+     */
+    export interface LinearOptimizationService {
+      Status: Status
+      VariableType: VariableType
+      createEngine(): LinearOptimizationEngine;
+    }
+
+    /**
+     * The solution of a linear program. The example below solves the following linear program:
+     * 
+     *  Two variables, x and y:
+     *  
+     * 0 ≤ x ≤ 10
+     * 
+     * 0 ≤ y ≤ 5
+     * 
+     *  Constraints:
+     *  
+     * 0 ≤ 2 * x + 5 * y ≤ 10
+     * 
+     * 0 ≤ 10 * x + 3 * y ≤ 20
+     * 
+     *  Objective:
+     *  Maximize x + y
+     * 
+     *      var engine = LinearOptimizationService.createEngine();
+     *     
+     *      // Add variables, constraints and define the objective with addVariable(), addConstraint(), etc.
+     *      // Add two variables, 0 <= x <= 10 and 0 <= y <= 5
+     *      engine.addVariable('x', 0, 10);
+     *      engine.addVariable('y', 0, 5);
+     *     
+     *      // Create the constraint: 0 <= 2 * x + 5 * y <= 10
+     *      var constraint = engine.addConstraint(0, 10);
+     *      constraint.setCoefficient('x', 2);
+     *      constraint.setCoefficient('y', 5);
+     *     
+     *      // Create the constraint: 0 <= 10 * x + 3 * y <= 20
+     *      var constraint = engine.addConstraint(0, 20);
+     *      constraint.setCoefficient('x', 10);
+     *      constraint.setCoefficient('y', 3);
+     *     
+     *      // Set the objective to be x + y
+     *      engine.setObjectiveCoefficient('x', 1);
+     *      engine.setObjectiveCoefficient('y', 1);
+     *     
+     *      // Engine should maximize the objective
+     *      engine.setMaximization();
+     *     
+     *      // Solve the linear program
+     *      var solution = engine.solve();
+     *      if (!solution.isValid()) {
+     *        Logger.log('No solution ' + solution.getStatus());
+     *      } else {
+     *        Logger.log('Objective  value: ' + solution.getObjectiveValue());
+     *        Logger.log('Value of x: ' + solution.getVariableValue('x'));
+     *        Logger.log('Value of y: ' + solution.getVariableValue('y'));
+     *      }
+     */
+    export interface LinearOptimizationSolution {
+      getObjectiveValue(): Number;
+      getStatus(): Status;
+      getVariableValue(variableName: string): Number;
+      isValid(): boolean;
+    }
+
+    /**
+     * Status of the solution. Before solving a problem the status will be NOT_SOLVED;
+     *  afterwards it will take any of the other values depending if it successfully found a solution and
+     *  if the solution is optimal.
+     */
+    export enum Status { OPTIMAL, FEASIBLE, INFEASIBLE, UNBOUNDED, ABNORMAL, MODEL_INVALID, NOT_SOLVED }
+
+    /**
+     * Type of variables created by the engine.
+     */
+    export enum VariableType { INTEGER, CONTINUOUS }
+
+  }
+}
+
+declare var LinearOptimizationService: GoogleAppsScript.Optimization.LinearOptimizationService;

google-apps-script/google-apps-script.properties.d.ts

@@ -0,0 +1,86 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Properties {
+    /**
+     * The properties object acts as the interface to access user, document, or script properties.
+     *  The specific property type depends on which of the three methods of
+     *  PropertiesService the script called:
+     *  PropertiesService.getDocumentProperties(),
+     *  PropertiesService.getUserProperties(), or
+     *  PropertiesService.getScriptProperties(). Properties cannot be shared between scripts. For
+     *  more information about property types, see the
+     *  guide to the Properties service.
+     */
+    export interface Properties {
+      deleteAllProperties(): Properties;
+      deleteProperty(key: string): Properties;
+      getKeys(): String[];
+      getProperties(): Object;
+      getProperty(key: string): string;
+      setProperties(properties: Object): Properties;
+      setProperties(properties: Object, deleteAllOthers: boolean): Properties;
+      setProperty(key: string, value: string): Properties;
+    }
+
+    /**
+     * Allows scripts to store simple data in key-value pairs scoped to one script, one user of a
+     *  script, or one document in which an add-on is used. Properties cannot be shared between scripts.
+     *  For more information about when to use each type of property, see the 
+     *  guide to the Properties service.
+     * 
+     *      // Sets three properties of different types.
+     *      var documentProperties = PropertiesService.getDocumentProperties();
+     *      var scriptProperties = PropertiesService.getScriptProperties();
+     *      var userProperties = PropertiesService.getUserProperties();
+     *     
+     *      documentProperties.setProperty('DAYS_TO_FETCH', '5');
+     *      scriptProperties.setProperty('SERVER_URL', 'http://www.example.com/MyWeatherService/');
+     *      userProperties.setProperty('DISPLAY_UNITS', 'metric');
+     */
+    export interface PropertiesService {
+      getDocumentProperties(): Properties;
+      getScriptProperties(): Properties;
+      getUserProperties(): Properties;
+    }
+
+    /**
+     * 
+     * Deprecated. This class is deprecated and should not be used in new scripts.
+     * Script Properties are key-value pairs stored by a script in a persistent store. Script Properties
+     *  are scoped per script, regardless of which user runs the script.
+     */
+    export interface ScriptProperties {
+      deleteAllProperties(): ScriptProperties;
+      deleteProperty(key: string): ScriptProperties;
+      getKeys(): String[];
+      getProperties(): Object;
+      getProperty(key: string): string;
+      setProperties(properties: Object): ScriptProperties;
+      setProperties(properties: Object, deleteAllOthers: boolean): ScriptProperties;
+      setProperty(key: string, value: string): ScriptProperties;
+    }
+
+    /**
+     * 
+     * Deprecated. This class is deprecated and should not be used in new scripts.
+     * User Properties are key-value pairs unique to a user. User Properties are scoped per user; any
+     *  script running under the identity of a user can access User Properties for that user only.
+     */
+    export interface UserProperties {
+      deleteAllProperties(): UserProperties;
+      deleteProperty(key: string): UserProperties;
+      getKeys(): String[];
+      getProperties(): Object;
+      getProperty(key: string): string;
+      setProperties(properties: Object): UserProperties;
+      setProperties(properties: Object, deleteAllOthers: boolean): UserProperties;
+      setProperty(key: string, value: string): UserProperties;
+    }
+
+  }
+}
+
+declare var PropertiesService: GoogleAppsScript.Properties.PropertiesService;
+declare var ScriptProperties: GoogleAppsScript.Properties.ScriptProperties;
+declare var UserProperties: GoogleAppsScript.Properties.UserProperties;

google-apps-script/google-apps-script.script.d.ts

@@ -0,0 +1,210 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+/// <reference path="google-apps-script.document.d.ts" />
+/// <reference path="google-apps-script.forms.d.ts" />
+/// <reference path="google-apps-script.spreadsheet.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Script {
+    /**
+     * An enumeration that identifies which categories of authorized services Apps Script
+     *  is able to execute through a triggered function. These values are exposed in
+     *  triggered functions as the authMode
+     *  property of the event parameter, e. For
+     *  more information, see the
+     *  guide to the authorization lifecycle for add-ons.
+     * 
+     *      function onOpen(e) {
+     *        var menu = SpreadsheetApp.getUi().createAddonMenu();
+     *        if (e && e.authMode == ScriptApp.AuthMode.NONE) {
+     *          // Add a normal menu item (works in all authorization modes).
+     *          menu.addItem('Start workflow', 'startWorkflow');
+     *        } else {
+     *          // Add a menu item based on properties (doesn't work in AuthMode.NONE).
+     *          var properties = PropertiesService.getDocumentProperties();
+     *          var workflowStarted = properties.getProperty('workflowStarted');
+     *          if (workflowStarted) {
+     *            menu.addItem('Check workflow status', 'checkWorkflow');
+     *          } else {
+     *            menu.addItem('Start workflow', 'startWorkflow');
+     *          }
+     *          // Record analytics.
+     *          UrlFetchApp.fetch('http://www.example.com/analytics?event=open');
+     *        }
+     *        menu.addToUi();
+     *      }
+     */
+    export enum AuthMode { NONE, CUSTOM_FUNCTION, LIMITED, FULL }
+
+    /**
+     * An object used to determine whether the user needs to authorize this script to use
+     *  one or more services, and to provide the URL for an authorization dialog. If the script
+     *  is published as an add-on that uses
+     *  installable triggers, this information
+     *  can be used to control access to sections of code for which the user lacks the necessary
+     *  authorization. Alternately, the add-on can ask the user to open the URL for the
+     *  authorization dialog to resolve the problem.
+     * 
+     * This object is returned by
+     *  ScriptApp.getAuthorizationInfo(authMode). In almost all cases,
+     *  scripts should call
+     *  ScriptApp.getAuthorizationInfo(ScriptApp.AuthMode.FULL), since no other
+     *  authorization mode requires that users grant authorization.
+     */
+    export interface AuthorizationInfo {
+      getAuthorizationStatus(): AuthorizationStatus;
+      getAuthorizationUrl(): string;
+    }
+
+    /**
+     * An enumeration denoting the authorization status of a script.
+     */
+    export enum AuthorizationStatus { REQUIRED, NOT_REQUIRED }
+
+    /**
+     * A builder for clock triggers.
+     */
+    export interface ClockTriggerBuilder {
+      after(durationMilliseconds: Integer): ClockTriggerBuilder;
+      at(date: Date): ClockTriggerBuilder;
+      atDate(year: Integer, month: Integer, day: Integer): ClockTriggerBuilder;
+      atHour(hour: Integer): ClockTriggerBuilder;
+      create(): Trigger;
+      everyDays(n: Integer): ClockTriggerBuilder;
+      everyHours(n: Integer): ClockTriggerBuilder;
+      everyMinutes(n: Integer): ClockTriggerBuilder;
+      everyWeeks(n: Integer): ClockTriggerBuilder;
+      inTimezone(timezone: string): ClockTriggerBuilder;
+      nearMinute(minute: Integer): ClockTriggerBuilder;
+      onMonthDay(day: Integer): ClockTriggerBuilder;
+      onWeekDay(day: Base.Weekday): ClockTriggerBuilder;
+    }
+
+    /**
+     * A builder for document triggers.
+     */
+    export interface DocumentTriggerBuilder {
+      create(): Trigger;
+      onOpen(): DocumentTriggerBuilder;
+    }
+
+    /**
+     * An enumeration denoting the type of triggered event.
+     */
+    export enum EventType { CLOCK, ON_OPEN, ON_EDIT, ON_FORM_SUBMIT, ON_CHANGE }
+
+    /**
+     * A builder for form triggers.
+     */
+    export interface FormTriggerBuilder {
+      create(): Trigger;
+      onFormSubmit(): FormTriggerBuilder;
+      onOpen(): FormTriggerBuilder;
+    }
+
+    /**
+     * An enumeration that indicates how the script came to be installed as an add-on for the
+     *  current user.
+     */
+    export enum InstallationSource { APPS_MARKETPLACE_DOMAIN_ADD_ON, NONE, WEB_STORE_ADD_ON }
+
+    /**
+     * Access and manipulate script publishing and triggers. This class allows users to create script
+     *  triggers and control publishing the script as a service.
+     */
+    export interface ScriptApp {
+      AuthMode: AuthMode
+      AuthorizationStatus: AuthorizationStatus
+      EventType: EventType
+      InstallationSource: InstallationSource
+      TriggerSource: TriggerSource
+      WeekDay: Base.Weekday
+      deleteTrigger(trigger: Trigger): void;
+      getAuthorizationInfo(authMode: AuthMode): AuthorizationInfo;
+      getInstallationSource(): InstallationSource;
+      getOAuthToken(): string;
+      getProjectKey(): string;
+      getProjectTriggers(): Trigger[];
+      getService(): Service;
+      getUserTriggers(document: Document.Document): Trigger[];
+      getUserTriggers(form: Forms.Form): Trigger[];
+      getUserTriggers(spreadsheet: Spreadsheet.Spreadsheet): Trigger[];
+      invalidateAuth(): void;
+      newStateToken(): StateTokenBuilder;
+      newTrigger(functionName: string): TriggerBuilder;
+      getScriptTriggers(): Trigger[];
+    }
+
+    /**
+     * 
+     */
+    export enum Service { MYSELF, DOMAIN, ALL }
+
+    /**
+     * Builder for spreadsheet triggers.
+     */
+    export interface SpreadsheetTriggerBuilder {
+      create(): Trigger;
+      onChange(): SpreadsheetTriggerBuilder;
+      onEdit(): SpreadsheetTriggerBuilder;
+      onFormSubmit(): SpreadsheetTriggerBuilder;
+      onOpen(): SpreadsheetTriggerBuilder;
+    }
+
+    /**
+     * Allows scripts to create state tokens that can be used in callback APIs (like OAuth flows).
+     * 
+     *      // Reusable function to generate a callback URL, assuming the script has been published as a
+     *      // web app (necessary to obtain the URL programmatically). If the script has not been published
+     *      // as a web app, set `var url` in the first line to the URL of your script project (which
+     *      // cannot be obtained programmatically).
+     *      function getCallbackURL(callbackFunction){
+     *        var url = ScriptApp.getService().getUrl();      // Ends in /exec (for a web app)
+     *        url = url.slice(0, -4) + 'usercallback?state='; // Change /exec to /usercallback
+     *        var stateToken = ScriptApp.newStateToken()
+     *            .withMethod(callbackFunction)
+     *            .withTimeout(120)
+     *            .createToken();
+     *        return url + stateToken;
+     *      }
+     */
+    export interface StateTokenBuilder {
+      createToken(): string;
+      withArgument(name: string, value: string): StateTokenBuilder;
+      withMethod(method: string): StateTokenBuilder;
+      withTimeout(seconds: Integer): StateTokenBuilder;
+    }
+
+    /**
+     * A script trigger.
+     */
+    export interface Trigger {
+      getEventType(): EventType;
+      getHandlerFunction(): string;
+      getTriggerSource(): TriggerSource;
+      getTriggerSourceId(): string;
+      getUniqueId(): string;
+    }
+
+    /**
+     * A generic builder for script triggers.
+     */
+    export interface TriggerBuilder {
+      forDocument(document: Document.Document): DocumentTriggerBuilder;
+      forDocument(key: string): DocumentTriggerBuilder;
+      forForm(form: Forms.Form): FormTriggerBuilder;
+      forForm(key: string): FormTriggerBuilder;
+      forSpreadsheet(sheet: Spreadsheet.Spreadsheet): SpreadsheetTriggerBuilder;
+      forSpreadsheet(key: string): SpreadsheetTriggerBuilder;
+      timeBased(): ClockTriggerBuilder;
+    }
+
+    /**
+     * An enumeration denoting the source of the event that causes the trigger to fire.
+     */
+    export enum TriggerSource { SPREADSHEETS, CLOCK, FORMS, DOCUMENTS }
+
+  }
+}
+
+declare var ScriptApp: GoogleAppsScript.Script.ScriptApp;

google-apps-script/google-apps-script.sites.d.ts

@@ -0,0 +1,236 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Sites {
+    /**
+     * A Sites Attachment such as a file attached to a page.
+     * 
+     *  Note that an Attachment is a Blob and can be used anywhere Blob input is expected.
+     * 
+     *      var filesPage = SitesApp.getSite('example.com', 'mysite').getChildByName("files");
+     *      var attachments = filesPage.getAttachments();
+     *     
+     *      // DocsList.createFile accepts a blob input. Since an Attachment is just a blob, we can
+     *      // just pass it directly to that method
+     *      var file = DocsList.createFile(attachments[0]);
+     */
+    export interface Attachment {
+      deleteAttachment(): void;
+      getAs(contentType: string): Base.Blob;
+      getAttachmentType(): AttachmentType;
+      getBlob(): Base.Blob;
+      getContentType(): string;
+      getDatePublished(): Date;
+      getDescription(): string;
+      getLastUpdated(): Date;
+      getParent(): Page;
+      getTitle(): string;
+      getUrl(): string;
+      setContentType(contentType: string): Attachment;
+      setDescription(description: string): Attachment;
+      setFrom(blob: Base.BlobSource): Attachment;
+      setParent(parent: Page): Attachment;
+      setTitle(title: string): Attachment;
+      setUrl(url: string): Attachment;
+    }
+
+    /**
+     * A typesafe enum for sites attachment type.
+     */
+    export enum AttachmentType { WEB, HOSTED }
+
+    /**
+     * A Sites Column - a column from a Sites List page.
+     */
+    export interface Column {
+      deleteColumn(): void;
+      getName(): string;
+      getParent(): Page;
+      setName(name: string): Column;
+    }
+
+    /**
+     * A Comment attached to any Sites page.
+     */
+    export interface Comment {
+      deleteComment(): void;
+      getAuthorEmail(): string;
+      getAuthorName(): string;
+      getContent(): string;
+      getDatePublished(): Date;
+      getLastUpdated(): Date;
+      getParent(): Page;
+      setContent(content: string): Comment;
+      setParent(parent: Page): Comment;
+    }
+
+    /**
+     * A Sites ListItem - a list element from a Sites List page.
+     */
+    export interface ListItem {
+      deleteListItem(): void;
+      getDatePublished(): Date;
+      getLastUpdated(): Date;
+      getParent(): Page;
+      getValueByIndex(index: Integer): string;
+      getValueByName(name: string): string;
+      setParent(parent: Page): ListItem;
+      setValueByIndex(index: Integer, value: string): ListItem;
+      setValueByName(name: string, value: string): ListItem;
+    }
+
+    /**
+     * A Page on a Google Site.
+     */
+    export interface Page {
+      addColumn(name: string): Column;
+      addHostedAttachment(blob: Base.BlobSource): Attachment;
+      addHostedAttachment(blob: Base.BlobSource, description: string): Attachment;
+      addListItem(values: String[]): ListItem;
+      addWebAttachment(title: string, description: string, url: string): Attachment;
+      createAnnouncement(title: string, html: string): Page;
+      createAnnouncement(title: string, html: string, asDraft: boolean): Page;
+      createAnnouncementsPage(title: string, name: string, html: string): Page;
+      createFileCabinetPage(title: string, name: string, html: string): Page;
+      createListPage(title: string, name: string, html: string, columnNames: String[]): Page;
+      createPageFromTemplate(title: string, name: string, template: Page): Page;
+      createWebPage(title: string, name: string, html: string): Page;
+      deletePage(): void;
+      getAllDescendants(): Page[];
+      getAllDescendants(options: Object): Page[];
+      getAnnouncements(): Page[];
+      getAnnouncements(optOptions: Object): Page[];
+      getAttachments(): Attachment[];
+      getAttachments(optOptions: Object): Attachment[];
+      getAuthors(): String[];
+      getChildByName(name: string): Page;
+      getChildren(): Page[];
+      getChildren(options: Object): Page[];
+      getColumns(): Column[];
+      getComments(): Comment[];
+      getComments(optOptions: Object): Comment[];
+      getDatePublished(): Date;
+      getHtmlContent(): string;
+      getIsDraft(): boolean;
+      getLastEdited(): Date;
+      getLastUpdated(): Date;
+      getListItems(): ListItem[];
+      getListItems(optOptions: Object): ListItem[];
+      getName(): string;
+      getPageType(): PageType;
+      getParent(): Page;
+      getTextContent(): string;
+      getTitle(): string;
+      getUrl(): string;
+      isDeleted(): boolean;
+      isTemplate(): boolean;
+      publishAsTemplate(name: string): Page;
+      search(query: string): Page[];
+      search(query: string, options: Object): Page[];
+      setHtmlContent(html: string): Page;
+      setIsDraft(draft: boolean): Page;
+      setName(name: string): Page;
+      setParent(parent: Page): Page;
+      setTitle(title: string): Page;
+      addComment(content: string): Comment;
+      getPageName(): string;
+      getSelfLink(): string;
+    }
+
+    /**
+     * A typesafe enum for sites page type.
+     */
+    export enum PageType { WEB_PAGE, LIST_PAGE, ANNOUNCEMENT, ANNOUNCEMENTS_PAGE, FILE_CABINET_PAGE }
+
+    /**
+     * An object representing a Google Site.
+     */
+    export interface Site {
+      addEditor(emailAddress: string): Site;
+      addEditor(user: Base.User): Site;
+      addEditors(emailAddresses: String[]): Site;
+      addOwner(email: string): Site;
+      addOwner(user: Base.User): Site;
+      addViewer(emailAddress: string): Site;
+      addViewer(user: Base.User): Site;
+      addViewers(emailAddresses: String[]): Site;
+      createAnnouncementsPage(title: string, name: string, html: string): Page;
+      createFileCabinetPage(title: string, name: string, html: string): Page;
+      createListPage(title: string, name: string, html: string, columnNames: String[]): Page;
+      createPageFromTemplate(title: string, name: string, template: Page): Page;
+      createWebPage(title: string, name: string, html: string): Page;
+      getAllDescendants(): Page[];
+      getAllDescendants(options: Object): Page[];
+      getChildByName(name: string): Page;
+      getChildren(): Page[];
+      getChildren(options: Object): Page[];
+      getEditors(): Base.User[];
+      getName(): string;
+      getOwners(): Base.User[];
+      getSummary(): string;
+      getTemplates(): Page[];
+      getTheme(): string;
+      getTitle(): string;
+      getUrl(): string;
+      getViewers(): Base.User[];
+      removeEditor(emailAddress: string): Site;
+      removeEditor(user: Base.User): Site;
+      removeOwner(email: string): Site;
+      removeOwner(user: Base.User): Site;
+      removeViewer(emailAddress: string): Site;
+      removeViewer(user: Base.User): Site;
+      search(query: string): Page[];
+      search(query: string, options: Object): Page[];
+      setSummary(summary: string): Site;
+      setTheme(theme: string): Site;
+      setTitle(title: string): Site;
+      addCollaborator(email: string): Site;
+      addCollaborator(user: Base.User): Site;
+      createAnnouncement(title: string, html: string, parent: Page): Page;
+      createComment(inReplyTo: string, html: string, parent: Page): Comment;
+      createListItem(html: string, columnNames: String[], values: String[], parent: Page): ListItem;
+      createWebAttachment(title: string, url: string, parent: Page): Attachment;
+      deleteSite(): void;
+      getAnnouncements(): Page[];
+      getAnnouncementsPages(): Page[];
+      getAttachments(): Attachment[];
+      getCollaborators(): Base.User[];
+      getComments(): Comment[];
+      getFileCabinetPages(): Page[];
+      getListItems(): ListItem[];
+      getListPages(): Page[];
+      getSelfLink(): string;
+      getSiteName(): string;
+      getWebAttachments(): Attachment[];
+      getWebPages(): Page[];
+      removeCollaborator(email: string): Site;
+      removeCollaborator(user: Base.User): Site;
+    }
+
+    /**
+     * Create and access Google Sites.
+     */
+    export interface SitesApp {
+      AttachmentType: AttachmentType
+      PageType: PageType
+      copySite(domain: string, name: string, title: string, summary: string, site: Site): Site;
+      createSite(domain: string, name: string, title: string, summary: string): Site;
+      getActivePage(): Page;
+      getActiveSite(): Site;
+      getAllSites(domain: string): Site[];
+      getAllSites(domain: string, start: Integer, max: Integer): Site[];
+      getPageByUrl(url: string): Page;
+      getSite(name: string): Site;
+      getSite(domain: string, name: string): Site;
+      getSiteByUrl(url: string): Site;
+      getSites(): Site[];
+      getSites(start: Integer, max: Integer): Site[];
+      getSites(domain: string): Site[];
+      getSites(domain: string, start: Integer, max: Integer): Site[];
+    }
+
+  }
+}
+
+declare var SitesApp: GoogleAppsScript.Sites.SitesApp;

google-apps-script/google-apps-script.spreadsheet.d.ts

@@ -0,0 +1,913 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.charts.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+/// <reference path="google-apps-script.drive.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Spreadsheet {
+    /**
+     * The chart's position within a sheet.  Can be updated using the EmbeddedChart.modify()
+     *  function.
+     * 
+     *      chart = chart.modify().setPosition(5, 5, 0, 0).build();
+     *      sheet.updateChart(chart);
+     */
+    export interface ContainerInfo {
+      getAnchorColumn(): Integer;
+      getAnchorRow(): Integer;
+      getOffsetX(): Integer;
+      getOffsetY(): Integer;
+    }
+
+    /**
+     * This class allows users to access existing data-validation rules. To create a new rule, see
+     *  SpreadsheetApp.newDataValidation(), DataValidationBuilder, and
+     *  Range.setDataValidation(rule).
+     * 
+     *      // Log information about the data-validation rule for cell A1.
+     *      var cell = SpreadsheetApp.getActive().getRange('A1');
+     *      var rule = cell.getDataValidation();
+     *      if (rule != null) {
+     *        var criteria = rule.getCriteriaType();
+     *        var args = rule.getCriteriaValues();
+     *        Logger.log('The data-validation rule is %s %s', criteria, args);
+     *      } else {
+     *        Logger.log('The cell does not have a data-validation rule.')
+     *      }
+     */
+    export interface DataValidation {
+      copy(): DataValidationBuilder;
+      getAllowInvalid(): boolean;
+      getCriteriaType(): DataValidationCriteria;
+      getCriteriaValues(): Object[];
+      getHelpText(): string;
+    }
+
+    /**
+     * Builder for data-validation rules.
+     * 
+     *      // Set the data validation for cell A1 to require a value from B1:B10.
+     *      var cell = SpreadsheetApp.getActive().getRange('A1');
+     *      var range = SpreadsheetApp.getActive().getRange('B1:B10');
+     *      var rule = SpreadsheetApp.newDataValidation().requireValueInRange(range).build();
+     *      cell.setDataValidation(rule);
+     */
+    export interface DataValidationBuilder {
+      build(): DataValidation;
+      copy(): DataValidationBuilder;
+      getAllowInvalid(): boolean;
+      getCriteriaType(): DataValidationCriteria;
+      getCriteriaValues(): Object[];
+      getHelpText(): string;
+      requireDate(): DataValidationBuilder;
+      requireDateAfter(date: Date): DataValidationBuilder;
+      requireDateBefore(date: Date): DataValidationBuilder;
+      requireDateBetween(start: Date, end: Date): DataValidationBuilder;
+      requireDateEqualTo(date: Date): DataValidationBuilder;
+      requireDateNotBetween(start: Date, end: Date): DataValidationBuilder;
+      requireDateOnOrAfter(date: Date): DataValidationBuilder;
+      requireDateOnOrBefore(date: Date): DataValidationBuilder;
+      requireFormulaSatisfied(formula: string): DataValidationBuilder;
+      requireNumberBetween(start: Number, end: Number): DataValidationBuilder;
+      requireNumberEqualTo(number: Number): DataValidationBuilder;
+      requireNumberGreaterThan(number: Number): DataValidationBuilder;
+      requireNumberGreaterThanOrEqualTo(number: Number): DataValidationBuilder;
+      requireNumberLessThan(number: Number): DataValidationBuilder;
+      requireNumberLessThanOrEqualTo(number: Number): DataValidationBuilder;
+      requireNumberNotBetween(start: Number, end: Number): DataValidationBuilder;
+      requireNumberNotEqualTo(number: Number): DataValidationBuilder;
+      requireTextContains(text: string): DataValidationBuilder;
+      requireTextDoesNotContain(text: string): DataValidationBuilder;
+      requireTextEqualTo(text: string): DataValidationBuilder;
+      requireTextIsEmail(): DataValidationBuilder;
+      requireTextIsUrl(): DataValidationBuilder;
+      requireValueInList(values: String[]): DataValidationBuilder;
+      requireValueInList(values: String[], showDropdown: boolean): DataValidationBuilder;
+      requireValueInRange(range: Range): DataValidationBuilder;
+      requireValueInRange(range: Range, showDropdown: boolean): DataValidationBuilder;
+      setAllowInvalid(allowInvalidData: boolean): DataValidationBuilder;
+      setHelpText(helpText: string): DataValidationBuilder;
+      withCriteria(criteria: DataValidationCriteria, args: Object[]): DataValidationBuilder;
+    }
+
+    /**
+     * An enumeration representing the data-validation criteria that can be set on a range.
+     * 
+     *      // Change existing data-validation rules that require a date in 2013 to require a date in 2014.
+     *      var oldDates = [new Date('1/1/2013'), new Date('12/31/2013')];
+     *      var newDates = [new Date('1/1/2014'), new Date('12/31/2014')];
+     *      var sheet = SpreadsheetApp.getActiveSheet();
+     *      var range = sheet.getRange(1, 1, sheet.getMaxRows(), sheet.getMaxColumns());
+     *      var rules = range.getDataValidations();
+     *     
+     *      for (var i = 0; i < rules.length; i++) {
+     *        for (var j = 0; j < rules[i].length; j++) {
+     *          var rule = rules[i][j];
+     *     
+     *          if (rule != null) {
+     *            var criteria = rule.getCriteriaType();
+     *            var args = rule.getCriteriaValues();
+     *      
+     *            if (criteria == SpreadsheetApp.DataValidationCriteria.DATE_BETWEEN
+     *                && args[0].getTime() == oldDates[0].getTime()
+     *                && args[1].getTime() == oldDates[1].getTime()) {
+     *              // Create a builder from the existing rule, then change the dates.
+     *              rules[i][j] = rule.copy().withCriteria(criteria, newDates).build();
+     *            }
+     *          }
+     *        }
+     *      }
+     *      range.setDataValidations(rules);
+     */
+    export enum DataValidationCriteria { DATE_AFTER, DATE_BEFORE, DATE_BETWEEN, DATE_EQUAL_TO, DATE_IS_VALID_DATE, DATE_NOT_BETWEEN, DATE_ON_OR_AFTER, DATE_ON_OR_BEFORE, NUMBER_BETWEEN, NUMBER_EQUAL_TO, NUMBER_GREATER_THAN, NUMBER_GREATER_THAN_OR_EQUAL_TO, NUMBER_LESS_THAN, NUMBER_LESS_THAN_OR_EQUAL_TO, NUMBER_NOT_BETWEEN, NUMBER_NOT_EQUAL_TO, TEXT_CONTAINS, TEXT_DOES_NOT_CONTAIN, TEXT_EQUAL_TO, TEXT_IS_VALID_EMAIL, TEXT_IS_VALID_URL, VALUE_IN_LIST, VALUE_IN_RANGE, CUSTOM_FORMULA }
+
+    /**
+     * Builder for area charts. For more details, see the Gviz 
+     *  documentation.
+     */
+    export interface EmbeddedAreaChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      reverseCategories(): EmbeddedAreaChartBuilder;
+      setBackgroundColor(cssValue: string): EmbeddedAreaChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setColors(cssValues: String[]): EmbeddedAreaChartBuilder;
+      setLegendPosition(position: Charts.Position): EmbeddedAreaChartBuilder;
+      setLegendTextStyle(textStyle: Charts.TextStyle): EmbeddedAreaChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPointStyle(style: Charts.PointStyle): EmbeddedAreaChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+      setRange(start: Number, end: Number): EmbeddedAreaChartBuilder;
+      setStacked(): EmbeddedAreaChartBuilder;
+      setTitle(chartTitle: string): EmbeddedAreaChartBuilder;
+      setTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedAreaChartBuilder;
+      setXAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedAreaChartBuilder;
+      setXAxisTitle(title: string): EmbeddedAreaChartBuilder;
+      setXAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedAreaChartBuilder;
+      setYAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedAreaChartBuilder;
+      setYAxisTitle(title: string): EmbeddedAreaChartBuilder;
+      setYAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedAreaChartBuilder;
+      useLogScale(): EmbeddedAreaChartBuilder;
+    }
+
+    /**
+     * Builder for bar charts. For more details, see the Gviz 
+     *  documentation.
+     */
+    export interface EmbeddedBarChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      reverseCategories(): EmbeddedBarChartBuilder;
+      reverseDirection(): EmbeddedBarChartBuilder;
+      setBackgroundColor(cssValue: string): EmbeddedBarChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setColors(cssValues: String[]): EmbeddedBarChartBuilder;
+      setLegendPosition(position: Charts.Position): EmbeddedBarChartBuilder;
+      setLegendTextStyle(textStyle: Charts.TextStyle): EmbeddedBarChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+      setRange(start: Number, end: Number): EmbeddedBarChartBuilder;
+      setStacked(): EmbeddedBarChartBuilder;
+      setTitle(chartTitle: string): EmbeddedBarChartBuilder;
+      setTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedBarChartBuilder;
+      setXAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedBarChartBuilder;
+      setXAxisTitle(title: string): EmbeddedBarChartBuilder;
+      setXAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedBarChartBuilder;
+      setYAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedBarChartBuilder;
+      setYAxisTitle(title: string): EmbeddedBarChartBuilder;
+      setYAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedBarChartBuilder;
+      useLogScale(): EmbeddedBarChartBuilder;
+    }
+
+    /**
+     * Represents a chart that has been embedded into a Spreadsheet.
+     * 
+     * This example shows how to modify an existing chart:
+     * 
+     *      var sheet = SpreadsheetApp.getActiveSheet();
+     *      var range = sheet.getRange("A2:B8")
+     *      var chart = sheet.getCharts()[0];
+     *      chart = chart.modify()
+     *          .addRange(range)
+     *          .setOption('title', 'Updated!')
+     *          .setOption('animation.duration', 500)
+     *          .setPosition(2,2,0,0)
+     *          .build();
+     *      sheet.updateChart(chart);
+     * 
+     * This example shows how to create a new chart:
+     * 
+     *      function newChart(range, sheet) {
+     *        var sheet = SpreadsheetApp.getActiveSheet();
+     *        var chartBuilder = sheet.newChart();
+     *        chartBuilder.addRange(range)
+     *            .setChartType(Charts.ChartType.LINE)
+     *            .setOption('title', 'My Line Chart!');
+     *        sheet.insertChart(chartBuilder.build());
+     *      }
+     */
+    export interface EmbeddedChart {
+      getAs(contentType: string): Base.Blob;
+      getBlob(): Base.Blob;
+      getContainerInfo(): ContainerInfo;
+      getId(): string;
+      getOptions(): Charts.ChartOptions;
+      getRanges(): Range[];
+      getType(): string;
+      modify(): EmbeddedChartBuilder;
+      setId(id: string): Charts.Chart;
+    }
+
+    /**
+     * This builder allows you to edit an EmbeddedChart. Make sure to call
+     *  sheet.updateChart(builder.build()) to save your changes.
+     * 
+     *      var sheet = SpreadsheetApp.getActiveSheet();
+     *      var range = sheet.getRange("A1:B8");
+     *      var chart = sheet.getCharts()[0];
+     *      chart = chart.modify()
+     *          .addRange(range)
+     *          .setOption('title', 'Updated!')
+     *          .setOption('animation.duration', 500)
+     *          .setPosition(2,2,0,0)
+     *          .build();
+     *      sheet.updateChart(chart);
+     */
+    export interface EmbeddedChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+    }
+
+    /**
+     * Builder for column charts. For more details, see the Gviz 
+     *  documentation.
+     */
+    export interface EmbeddedColumnChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      reverseCategories(): EmbeddedColumnChartBuilder;
+      setBackgroundColor(cssValue: string): EmbeddedColumnChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setColors(cssValues: String[]): EmbeddedColumnChartBuilder;
+      setLegendPosition(position: Charts.Position): EmbeddedColumnChartBuilder;
+      setLegendTextStyle(textStyle: Charts.TextStyle): EmbeddedColumnChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+      setRange(start: Number, end: Number): EmbeddedColumnChartBuilder;
+      setStacked(): EmbeddedColumnChartBuilder;
+      setTitle(chartTitle: string): EmbeddedColumnChartBuilder;
+      setTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedColumnChartBuilder;
+      setXAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedColumnChartBuilder;
+      setXAxisTitle(title: string): EmbeddedColumnChartBuilder;
+      setXAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedColumnChartBuilder;
+      setYAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedColumnChartBuilder;
+      setYAxisTitle(title: string): EmbeddedColumnChartBuilder;
+      setYAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedColumnChartBuilder;
+      useLogScale(): EmbeddedColumnChartBuilder;
+    }
+
+    /**
+     * Builder for line charts. For more details, see the Gviz 
+     *  documentation.
+     */
+    export interface EmbeddedLineChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      reverseCategories(): EmbeddedLineChartBuilder;
+      setBackgroundColor(cssValue: string): EmbeddedLineChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setColors(cssValues: String[]): EmbeddedLineChartBuilder;
+      setCurveStyle(style: Charts.CurveStyle): EmbeddedLineChartBuilder;
+      setLegendPosition(position: Charts.Position): EmbeddedLineChartBuilder;
+      setLegendTextStyle(textStyle: Charts.TextStyle): EmbeddedLineChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPointStyle(style: Charts.PointStyle): EmbeddedLineChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+      setRange(start: Number, end: Number): EmbeddedLineChartBuilder;
+      setTitle(chartTitle: string): EmbeddedLineChartBuilder;
+      setTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedLineChartBuilder;
+      setXAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedLineChartBuilder;
+      setXAxisTitle(title: string): EmbeddedLineChartBuilder;
+      setXAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedLineChartBuilder;
+      setYAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedLineChartBuilder;
+      setYAxisTitle(title: string): EmbeddedLineChartBuilder;
+      setYAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedLineChartBuilder;
+      useLogScale(): EmbeddedLineChartBuilder;
+    }
+
+    /**
+     * Builder for pie charts. For more details, see the Gviz 
+     *  documentation.
+     */
+    export interface EmbeddedPieChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      reverseCategories(): EmbeddedPieChartBuilder;
+      set3D(): EmbeddedPieChartBuilder;
+      setBackgroundColor(cssValue: string): EmbeddedPieChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setColors(cssValues: String[]): EmbeddedPieChartBuilder;
+      setLegendPosition(position: Charts.Position): EmbeddedPieChartBuilder;
+      setLegendTextStyle(textStyle: Charts.TextStyle): EmbeddedPieChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+      setTitle(chartTitle: string): EmbeddedPieChartBuilder;
+      setTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedPieChartBuilder;
+    }
+
+    /**
+     * Builder for scatter charts. For more details, see the Gviz 
+     *  documentation.
+     */
+    export interface EmbeddedScatterChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      setBackgroundColor(cssValue: string): EmbeddedScatterChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setColors(cssValues: String[]): EmbeddedScatterChartBuilder;
+      setLegendPosition(position: Charts.Position): EmbeddedScatterChartBuilder;
+      setLegendTextStyle(textStyle: Charts.TextStyle): EmbeddedScatterChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPointStyle(style: Charts.PointStyle): EmbeddedScatterChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+      setTitle(chartTitle: string): EmbeddedScatterChartBuilder;
+      setTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedScatterChartBuilder;
+      setXAxisLogScale(): EmbeddedScatterChartBuilder;
+      setXAxisRange(start: Number, end: Number): EmbeddedScatterChartBuilder;
+      setXAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedScatterChartBuilder;
+      setXAxisTitle(title: string): EmbeddedScatterChartBuilder;
+      setXAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedScatterChartBuilder;
+      setYAxisLogScale(): EmbeddedScatterChartBuilder;
+      setYAxisRange(start: Number, end: Number): EmbeddedScatterChartBuilder;
+      setYAxisTextStyle(textStyle: Charts.TextStyle): EmbeddedScatterChartBuilder;
+      setYAxisTitle(title: string): EmbeddedScatterChartBuilder;
+      setYAxisTitleTextStyle(textStyle: Charts.TextStyle): EmbeddedScatterChartBuilder;
+    }
+
+    /**
+     * Builder for table charts. For more details, see the Gviz 
+     *  documentation.
+     */
+    export interface EmbeddedTableChartBuilder {
+      addRange(range: Range): EmbeddedChartBuilder;
+      asAreaChart(): EmbeddedAreaChartBuilder;
+      asBarChart(): EmbeddedBarChartBuilder;
+      asColumnChart(): EmbeddedColumnChartBuilder;
+      asLineChart(): EmbeddedLineChartBuilder;
+      asPieChart(): EmbeddedPieChartBuilder;
+      asScatterChart(): EmbeddedScatterChartBuilder;
+      asTableChart(): EmbeddedTableChartBuilder;
+      build(): EmbeddedChart;
+      enablePaging(enablePaging: boolean): EmbeddedTableChartBuilder;
+      enablePaging(pageSize: Integer): EmbeddedTableChartBuilder;
+      enablePaging(pageSize: Integer, startPage: Integer): EmbeddedTableChartBuilder;
+      enableRtlTable(rtlEnabled: boolean): EmbeddedTableChartBuilder;
+      enableSorting(enableSorting: boolean): EmbeddedTableChartBuilder;
+      getChartType(): Charts.ChartType;
+      getContainer(): ContainerInfo;
+      getRanges(): Range[];
+      removeRange(range: Range): EmbeddedChartBuilder;
+      setChartType(type: Charts.ChartType): EmbeddedChartBuilder;
+      setFirstRowNumber(number: Integer): EmbeddedTableChartBuilder;
+      setInitialSortingAscending(column: Integer): EmbeddedTableChartBuilder;
+      setInitialSortingDescending(column: Integer): EmbeddedTableChartBuilder;
+      setOption(option: string, value: Object): EmbeddedChartBuilder;
+      setPosition(anchorRowPos: Integer, anchorColPos: Integer, offsetX: Integer, offsetY: Integer): EmbeddedChartBuilder;
+      showRowNumberColumn(showRowNumber: boolean): EmbeddedTableChartBuilder;
+      useAlternatingRowStyle(alternate: boolean): EmbeddedTableChartBuilder;
+    }
+
+    /**
+     * 
+     * Deprecated. For spreadsheets created in the newer version of Google Sheets, use the more powerful
+     *      Protection class instead. Although this class is deprecated, it will remain
+     *      available for compatibility with the older version of Sheets.
+     * Access and modify protected sheets in the older version of Google Sheets.
+     */
+    export interface PageProtection {
+      addUser(email: string): void;
+      getUsers(): String[];
+      isProtected(): boolean;
+      removeUser(user: string): void;
+      setProtected(protection: boolean): void;
+    }
+
+    /**
+     * Access and modify protected ranges and sheets. A protected range can protect either a static
+     *  range of cells or a named range. A protected sheet may include unprotected regions. For
+     *  spreadsheets created with the older version of Google Sheets, use the PageProtection
+     *  class instead.
+     * 
+     *      // Protect range A1:B10, then remove all other users from the list of editors.
+     *      var ss = SpreadsheetApp.getActive();
+     *      var range = ss.getRange('A1:B10');
+     *      var protection = range.protect().setDescription('Sample protected range');
+     *     
+     *      // Ensure the current user is an editor before removing others. Otherwise, if the user's edit
+     *      // permission comes from a group, the script will throw an exception upon removing the group.
+     *      var me = Session.getEffectiveUser();
+     *      protection.addEditor(me);
+     *      protection.removeEditors(protection.getEditors());
+     *      if (protection.canDomainEdit()) {
+     *        protection.setDomainEdit(false);
+     *      }
+     * 
+     *      // Remove all range protections in the spreadsheet that the user has permission to edit.
+     *      var ss = SpreadsheetApp.getActive();
+     *      var protections = ss.getProtections(SpreadsheetApp.ProtectionType.RANGE);
+     *      for (var i = 0; i < protections.length; i++) {
+     *        var protection = protections[i];
+     *        if (protection.canEdit()) {
+     *          protection.remove();
+     *        }
+     *      }
+     * 
+     *      // Protect the active sheet, then remove all other users from the list of editors.
+     *      var sheet = SpreadsheetApp.getActiveSheet();
+     *      var protection = sheet.protect().setDescription('Sample protected sheet');
+     *     
+     *      // Ensure the current user is an editor before removing others. Otherwise, if the user's edit
+     *      // permission comes from a group, the script will throw an exception upon removing the group.
+     *      var me = Session.getEffectiveUser();
+     *      protection.addEditor(me);
+     *      protection.removeEditors(protection.getEditors());
+     *      if (protection.canDomainEdit()) {
+     *        protection.setDomainEdit(false);
+     *      }
+     */
+    export interface Protection {
+      addEditor(emailAddress: string): Protection;
+      addEditor(user: Base.User): Protection;
+      addEditors(emailAddresses: String[]): Protection;
+      canDomainEdit(): boolean;
+      canEdit(): boolean;
+      getDescription(): string;
+      getEditors(): Base.User[];
+      getProtectionType(): ProtectionType;
+      getRange(): Range;
+      getRangeName(): string;
+      getUnprotectedRanges(): Range[];
+      isWarningOnly(): boolean;
+      remove(): void;
+      removeEditor(emailAddress: string): Protection;
+      removeEditor(user: Base.User): Protection;
+      removeEditors(emailAddresses: String[]): Protection;
+      setDescription(description: string): Protection;
+      setDomainEdit(editable: boolean): Protection;
+      setRange(range: Range): Protection;
+      setRangeName(rangeName: string): Protection;
+      setUnprotectedRanges(ranges: Range[]): Protection;
+      setWarningOnly(warningOnly: boolean): Protection;
+    }
+
+    /**
+     * An enumeration representing the parts of a spreadsheet that can be protected from edits.
+     * 
+     *      // Remove all range protections in the spreadsheet that the user has permission to edit.
+     *      var ss = SpreadsheetApp.getActive();
+     *      var protections = ss.getProtections(SpreadsheetApp.ProtectionType.RANGE);
+     *      for (var i = 0; i < protections.length; i++) {
+     *        var protection = protections[i];
+     *        if (protection.canEdit()) {
+     *          protection.remove();
+     *        }
+     *      }
+     * 
+     *      // Removes sheet protection from the active sheet, if the user has permission to edit it.
+     *      var sheet = SpreadsheetApp.getActiveSheet();
+     *      var protection = sheet.getProtections(SpreadsheetApp.ProtectionType.SHEET)[0];
+     *      if (protection && protection.canEdit()) {
+     *        protection.remove();
+     *      }
+     */
+    export enum ProtectionType { RANGE, SHEET }
+
+    /**
+     * Access and modify spreadsheet ranges.
+     * 
+     *  This class allows users to access and modify ranges in Google Sheets. A range can be
+     *  a single cell in a sheet or a range of cells in a sheet.
+     */
+    export interface Range {
+      activate(): Range;
+      breakApart(): Range;
+      canEdit(): boolean;
+      clear(): Range;
+      clear(options: Object): Range;
+      clearContent(): Range;
+      clearDataValidations(): Range;
+      clearFormat(): Range;
+      clearNote(): Range;
+      copyFormatToRange(gridId: Integer, column: Integer, columnEnd: Integer, row: Integer, rowEnd: Integer): void;
+      copyFormatToRange(sheet: Sheet, column: Integer, columnEnd: Integer, row: Integer, rowEnd: Integer): void;
+      copyTo(destination: Range): void;
+      copyTo(destination: Range, options: Object): void;
+      copyValuesToRange(gridId: Integer, column: Integer, columnEnd: Integer, row: Integer, rowEnd: Integer): void;
+      copyValuesToRange(sheet: Sheet, column: Integer, columnEnd: Integer, row: Integer, rowEnd: Integer): void;
+      getA1Notation(): string;
+      getBackground(): string;
+      getBackgrounds(): String[][];
+      getCell(row: Integer, column: Integer): Range;
+      getColumn(): Integer;
+      getDataSourceUrl(): string;
+      getDataTable(): Charts.DataTable;
+      getDataTable(firstRowIsHeader: boolean): Charts.DataTable;
+      getDataValidation(): DataValidation;
+      getDataValidations(): DataValidation[][];
+      getFontColor(): string;
+      getFontColors(): String[][];
+      getFontFamilies(): String[][];
+      getFontFamily(): string;
+      getFontLine(): string;
+      getFontLines(): String[][];
+      getFontSize(): Integer;
+      getFontSizes(): Integer[][];
+      getFontStyle(): string;
+      getFontStyles(): String[][];
+      getFontWeight(): string;
+      getFontWeights(): String[][];
+      getFormula(): string;
+      getFormulaR1C1(): string;
+      getFormulas(): String[][];
+      getFormulasR1C1(): String[][];
+      getGridId(): Integer;
+      getHeight(): Integer;
+      getHorizontalAlignment(): string;
+      getHorizontalAlignments(): String[][];
+      getLastColumn(): Integer;
+      getLastRow(): Integer;
+      getNote(): string;
+      getNotes(): String[][];
+      getNumColumns(): Integer;
+      getNumRows(): Integer;
+      getNumberFormat(): string;
+      getNumberFormats(): String[][];
+      getRow(): Integer;
+      getRowIndex(): Integer;
+      getSheet(): Sheet;
+      getValue(): Object;
+      getValues(): Object[][];
+      getVerticalAlignment(): string;
+      getVerticalAlignments(): String[][];
+      getWidth(): Integer;
+      getWrap(): boolean;
+      getWraps(): Boolean[][];
+      isBlank(): boolean;
+      isEndColumnBounded(): boolean;
+      isEndRowBounded(): boolean;
+      isStartColumnBounded(): boolean;
+      isStartRowBounded(): boolean;
+      merge(): Range;
+      mergeAcross(): Range;
+      mergeVertically(): Range;
+      moveTo(target: Range): void;
+      offset(rowOffset: Integer, columnOffset: Integer): Range;
+      offset(rowOffset: Integer, columnOffset: Integer, numRows: Integer): Range;
+      offset(rowOffset: Integer, columnOffset: Integer, numRows: Integer, numColumns: Integer): Range;
+      protect(): Protection;
+      setBackground(color: string): Range;
+      setBackgroundRGB(red: Integer, green: Integer, blue: Integer): Range;
+      setBackgrounds(color: String[][]): Range;
+      setBorder(top: boolean, left: boolean, bottom: boolean, right: boolean, vertical: boolean, horizontal: boolean): Range;
+      setDataValidation(rule: DataValidation): Range;
+      setDataValidations(rules: DataValidation[][]): Range;
+      setFontColor(color: string): Range;
+      setFontColors(colors: Object[][]): Range;
+      setFontFamilies(fontFamilies: Object[][]): Range;
+      setFontFamily(fontFamily: string): Range;
+      setFontLine(fontLine: string): Range;
+      setFontLines(fontLines: Object[][]): Range;
+      setFontSize(size: Integer): Range;
+      setFontSizes(sizes: Object[][]): Range;
+      setFontStyle(fontStyle: string): Range;
+      setFontStyles(fontStyles: Object[][]): Range;
+      setFontWeight(fontWeight: string): Range;
+      setFontWeights(fontWeights: Object[][]): Range;
+      setFormula(formula: string): Range;
+      setFormulaR1C1(formula: string): Range;
+      setFormulas(formulas: String[][]): Range;
+      setFormulasR1C1(formulas: String[][]): Range;
+      setHorizontalAlignment(alignment: string): Range;
+      setHorizontalAlignments(alignments: Object[][]): Range;
+      setNote(note: string): Range;
+      setNotes(notes: Object[][]): Range;
+      setNumberFormat(numberFormat: string): Range;
+      setNumberFormats(numberFormats: Object[][]): Range;
+      setValue(value: Object): Range;
+      setValues(values: Object[][]): Range;
+      setVerticalAlignment(alignment: string): Range;
+      setVerticalAlignments(alignments: Object[][]): Range;
+      setWrap(isWrapEnabled: boolean): Range;
+      setWraps(isWrapEnabled: Object[][]): Range;
+      sort(sortSpecObj: Object): Range;
+    }
+
+    /**
+     * Access and modify spreadsheet sheets. Common operations
+     *  are renaming a sheet and accessing range objects from the sheet.
+     */
+    export interface Sheet {
+      activate(): Sheet;
+      appendRow(rowContents: Object[]): Sheet;
+      autoResizeColumn(columnPosition: Integer): Sheet;
+      clear(): Sheet;
+      clear(options: Object): Sheet;
+      clearContents(): Sheet;
+      clearFormats(): Sheet;
+      clearNotes(): Sheet;
+      copyTo(spreadsheet: Spreadsheet): Sheet;
+      deleteColumn(columnPosition: Integer): Sheet;
+      deleteColumns(columnPosition: Integer, howMany: Integer): void;
+      deleteRow(rowPosition: Integer): Sheet;
+      deleteRows(rowPosition: Integer, howMany: Integer): void;
+      getActiveCell(): Range;
+      getActiveRange(): Range;
+      getCharts(): EmbeddedChart[];
+      getColumnWidth(columnPosition: Integer): Integer;
+      getDataRange(): Range;
+      getFrozenColumns(): Integer;
+      getFrozenRows(): Integer;
+      getIndex(): Integer;
+      getLastColumn(): Integer;
+      getLastRow(): Integer;
+      getMaxColumns(): Integer;
+      getMaxRows(): Integer;
+      getName(): string;
+      getParent(): Spreadsheet;
+      getProtections(type: ProtectionType): Protection[];
+      getRange(row: Integer, column: Integer): Range;
+      getRange(row: Integer, column: Integer, numRows: Integer): Range;
+      getRange(row: Integer, column: Integer, numRows: Integer, numColumns: Integer): Range;
+      getRange(a1Notation: string): Range;
+      getRowHeight(rowPosition: Integer): Integer;
+      getSheetId(): Integer;
+      getSheetName(): string;
+      getSheetValues(startRow: Integer, startColumn: Integer, numRows: Integer, numColumns: Integer): Object[][];
+      hideColumn(column: Range): void;
+      hideColumns(columnIndex: Integer): void;
+      hideColumns(columnIndex: Integer, numColumns: Integer): void;
+      hideRow(row: Range): void;
+      hideRows(rowIndex: Integer): void;
+      hideRows(rowIndex: Integer, numRows: Integer): void;
+      hideSheet(): Sheet;
+      insertChart(chart: EmbeddedChart): void;
+      insertColumnAfter(afterPosition: Integer): Sheet;
+      insertColumnBefore(beforePosition: Integer): Sheet;
+      insertColumns(columnIndex: Integer): void;
+      insertColumns(columnIndex: Integer, numColumns: Integer): void;
+      insertColumnsAfter(afterPosition: Integer, howMany: Integer): Sheet;
+      insertColumnsBefore(beforePosition: Integer, howMany: Integer): Sheet;
+      insertImage(blob: Base.Blob, column: Integer, row: Integer): void;
+      insertImage(blob: Base.Blob, column: Integer, row: Integer, offsetX: Integer, offsetY: Integer): void;
+      insertImage(url: string, column: Integer, row: Integer): void;
+      insertImage(url: string, column: Integer, row: Integer, offsetX: Integer, offsetY: Integer): void;
+      insertRowAfter(afterPosition: Integer): Sheet;
+      insertRowBefore(beforePosition: Integer): Sheet;
+      insertRows(rowIndex: Integer): void;
+      insertRows(rowIndex: Integer, numRows: Integer): void;
+      insertRowsAfter(afterPosition: Integer, howMany: Integer): Sheet;
+      insertRowsBefore(beforePosition: Integer, howMany: Integer): Sheet;
+      isSheetHidden(): boolean;
+      newChart(): EmbeddedChartBuilder;
+      protect(): Protection;
+      removeChart(chart: EmbeddedChart): void;
+      setActiveRange(range: Range): Range;
+      setActiveSelection(range: Range): Range;
+      setActiveSelection(a1Notation: string): Range;
+      setColumnWidth(columnPosition: Integer, width: Integer): Sheet;
+      setFrozenColumns(columns: Integer): void;
+      setFrozenRows(rows: Integer): void;
+      setName(name: string): Sheet;
+      setRowHeight(rowPosition: Integer, height: Integer): Sheet;
+      showColumns(columnIndex: Integer): void;
+      showColumns(columnIndex: Integer, numColumns: Integer): void;
+      showRows(rowIndex: Integer): void;
+      showRows(rowIndex: Integer, numRows: Integer): void;
+      showSheet(): Sheet;
+      sort(columnPosition: Integer): Sheet;
+      sort(columnPosition: Integer, ascending: boolean): Sheet;
+      unhideColumn(column: Range): void;
+      unhideRow(row: Range): void;
+      updateChart(chart: EmbeddedChart): void;
+      getSheetProtection(): PageProtection;
+      setSheetProtection(permissions: PageProtection): void;
+    }
+
+    /**
+     * This class allows users to access and modify Google Sheets files. Common operations are adding
+     *  new sheets and adding collaborators.
+     */
+    export interface Spreadsheet {
+      addEditor(emailAddress: string): Spreadsheet;
+      addEditor(user: Base.User): Spreadsheet;
+      addEditors(emailAddresses: String[]): Spreadsheet;
+      addMenu(name: string, subMenus: Object[]): void;
+      addViewer(emailAddress: string): Spreadsheet;
+      addViewer(user: Base.User): Spreadsheet;
+      addViewers(emailAddresses: String[]): Spreadsheet;
+      appendRow(rowContents: Object[]): Sheet;
+      autoResizeColumn(columnPosition: Integer): Sheet;
+      copy(name: string): Spreadsheet;
+      deleteActiveSheet(): Sheet;
+      deleteColumn(columnPosition: Integer): Sheet;
+      deleteColumns(columnPosition: Integer, howMany: Integer): void;
+      deleteRow(rowPosition: Integer): Sheet;
+      deleteRows(rowPosition: Integer, howMany: Integer): void;
+      deleteSheet(sheet: Sheet): void;
+      duplicateActiveSheet(): Sheet;
+      getActiveCell(): Range;
+      getActiveRange(): Range;
+      getActiveSheet(): Sheet;
+      getAs(contentType: string): Base.Blob;
+      getBlob(): Base.Blob;
+      getColumnWidth(columnPosition: Integer): Integer;
+      getDataRange(): Range;
+      getEditors(): Base.User[];
+      getFormUrl(): string;
+      getFrozenColumns(): Integer;
+      getFrozenRows(): Integer;
+      getId(): string;
+      getLastColumn(): Integer;
+      getLastRow(): Integer;
+      getName(): string;
+      getNumSheets(): Integer;
+      getOwner(): Base.User;
+      getProtections(type: ProtectionType): Protection[];
+      getRange(a1Notation: string): Range;
+      getRangeByName(name: string): Range;
+      getRowHeight(rowPosition: Integer): Integer;
+      getSheetByName(name: string): Sheet;
+      getSheetId(): Integer;
+      getSheetName(): string;
+      getSheetValues(startRow: Integer, startColumn: Integer, numRows: Integer, numColumns: Integer): Object[][];
+      getSheets(): Sheet[];
+      getSpreadsheetLocale(): string;
+      getSpreadsheetTimeZone(): string;
+      getUrl(): string;
+      getViewers(): Base.User[];
+      hideColumn(column: Range): void;
+      hideRow(row: Range): void;
+      insertColumnAfter(afterPosition: Integer): Sheet;
+      insertColumnBefore(beforePosition: Integer): Sheet;
+      insertColumnsAfter(afterPosition: Integer, howMany: Integer): Sheet;
+      insertColumnsBefore(beforePosition: Integer, howMany: Integer): Sheet;
+      insertImage(blob: Base.Blob, column: Integer, row: Integer): void;
+      insertImage(blob: Base.Blob, column: Integer, row: Integer, offsetX: Integer, offsetY: Integer): void;
+      insertImage(url: string, column: Integer, row: Integer): void;
+      insertImage(url: string, column: Integer, row: Integer, offsetX: Integer, offsetY: Integer): void;
+      insertRowAfter(afterPosition: Integer): Sheet;
+      insertRowBefore(beforePosition: Integer): Sheet;
+      insertRowsAfter(afterPosition: Integer, howMany: Integer): Sheet;
+      insertRowsBefore(beforePosition: Integer, howMany: Integer): Sheet;
+      insertSheet(): Sheet;
+      insertSheet(sheetIndex: Integer): Sheet;
+      insertSheet(sheetIndex: Integer, options: Object): Sheet;
+      insertSheet(options: Object): Sheet;
+      insertSheet(sheetName: string): Sheet;
+      insertSheet(sheetName: string, sheetIndex: Integer): Sheet;
+      insertSheet(sheetName: string, sheetIndex: Integer, options: Object): Sheet;
+      insertSheet(sheetName: string, options: Object): Sheet;
+      moveActiveSheet(pos: Integer): void;
+      removeEditor(emailAddress: string): Spreadsheet;
+      removeEditor(user: Base.User): Spreadsheet;
+      removeMenu(name: string): void;
+      removeNamedRange(name: string): void;
+      removeViewer(emailAddress: string): Spreadsheet;
+      removeViewer(user: Base.User): Spreadsheet;
+      rename(newName: string): void;
+      renameActiveSheet(newName: string): void;
+      setActiveRange(range: Range): Range;
+      setActiveSelection(range: Range): Range;
+      setActiveSelection(a1Notation: string): Range;
+      setActiveSheet(sheet: Sheet): Sheet;
+      setColumnWidth(columnPosition: Integer, width: Integer): Sheet;
+      setFrozenColumns(columns: Integer): void;
+      setFrozenRows(rows: Integer): void;
+      setNamedRange(name: string, range: Range): void;
+      setRowHeight(rowPosition: Integer, height: Integer): Sheet;
+      setSpreadsheetLocale(locale: string): void;
+      setSpreadsheetTimeZone(timezone: string): void;
+      show(userInterface: Object): void;
+      sort(columnPosition: Integer): Sheet;
+      sort(columnPosition: Integer, ascending: boolean): Sheet;
+      toast(msg: string): void;
+      toast(msg: string, title: string): void;
+      toast(msg: string, title: string, timeoutSeconds: Number): void;
+      unhideColumn(column: Range): void;
+      unhideRow(row: Range): void;
+      updateMenu(name: string, subMenus: Object[]): void;
+      getSheetProtection(): PageProtection;
+      isAnonymousView(): boolean;
+      isAnonymousWrite(): boolean;
+      setAnonymousAccess(anonymousReadAllowed: boolean, anonymousWriteAllowed: boolean): void;
+      setSheetProtection(permissions: PageProtection): void;
+    }
+
+    /**
+     * This class allows users to open Google Sheets files and to create new ones. This class is
+     *  the parent class for the Spreadsheet service.
+     */
+    export interface SpreadsheetApp {
+      DataValidationCriteria: DataValidationCriteria
+      ProtectionType: ProtectionType
+      create(name: string): Spreadsheet;
+      create(name: string, rows: Integer, columns: Integer): Spreadsheet;
+      flush(): void;
+      getActive(): Spreadsheet;
+      getActiveRange(): Range;
+      getActiveSheet(): Sheet;
+      getActiveSpreadsheet(): Spreadsheet;
+      getUi(): Base.Ui;
+      newDataValidation(): DataValidationBuilder;
+      open(file: Drive.File): Spreadsheet;
+      openById(id: string): Spreadsheet;
+      openByUrl(url: string): Spreadsheet;
+      setActiveRange(range: Range): Range;
+      setActiveSheet(sheet: Sheet): Sheet;
+      setActiveSpreadsheet(newActiveSpreadsheet: Spreadsheet): void;
+    }
+
+  }
+}
+
+declare var SpreadsheetApp: GoogleAppsScript.Spreadsheet.SpreadsheetApp;

google-apps-script/google-apps-script.types.d.ts

@@ -0,0 +1,7 @@
+declare module GoogleAppsScript {
+  type BigNumber = any;
+  type Byte = number;
+  type Integer = number;
+  type Char = string;
+  type JdbcSQL_XML = any;
+}

google-apps-script/google-apps-script.url-fetch.d.ts

@@ -0,0 +1,72 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module URL_Fetch {
+    /**
+     * This class allows users to access specific information on HTTP responses.
+     * See also
+     * 
+     * UrlFetchApp
+     */
+    export interface HTTPResponse {
+      getAllHeaders(): Object;
+      getAs(contentType: string): Base.Blob;
+      getBlob(): Base.Blob;
+      getContent(): Byte[];
+      getContentText(): string;
+      getContentText(charset: string): string;
+      getHeaders(): Object;
+      getResponseCode(): Integer;
+    }
+
+    /**
+     * 
+     * Deprecated. This class is deprecated and should not be used in new scripts.
+     * Represents configuration settings for an OAuth-enabled remote service.
+     * See also
+     * 
+     * UrlFetchApp
+     */
+    export interface OAuthConfig {
+      getAccessTokenUrl(): string;
+      getAuthorizationUrl(): string;
+      getMethod(): string;
+      getParamLocation(): string;
+      getRequestTokenUrl(): string;
+      getServiceName(): string;
+      setAccessTokenUrl(url: string): void;
+      setAuthorizationUrl(url: string): void;
+      setConsumerKey(consumerKey: string): void;
+      setConsumerSecret(consumerSecret: string): void;
+      setMethod(method: string): void;
+      setParamLocation(location: string): void;
+      setRequestTokenUrl(url: string): void;
+    }
+
+    /**
+     * Fetch resources and communicate with other hosts over the Internet.
+     * 
+     *  This service allows scripts to communicate with other applications or access other resources on
+     *  the web by fetching URLs. A script can use the URL Fetch service to issue HTTP and HTTPS requests
+     *  and receive responses. The URL Fetch service uses Google's network infrastructure for efficiency
+     *  and scaling purposes.
+     * See also
+     * 
+     * OAuthConfig
+     * 
+     * HTTPResponse
+     */
+    export interface UrlFetchApp {
+      fetch(url: string): HTTPResponse;
+      fetch(url: string, params: Object): HTTPResponse;
+      getRequest(url: string): Object;
+      getRequest(url: string, params: Object): Object;
+      addOAuthService(serviceName: string): OAuthConfig;
+      removeOAuthService(serviceName: string): void;
+    }
+
+  }
+}
+
+declare var UrlFetchApp: GoogleAppsScript.URL_Fetch.UrlFetchApp;

google-apps-script/google-apps-script.utilities.d.ts

@@ -0,0 +1,71 @@
+/// <reference path="google-apps-script.types.d.ts" />
+/// <reference path="google-apps-script.base.d.ts" />
+
+declare module GoogleAppsScript {
+  export module Utilities {
+    /**
+     * A typesafe enum for character sets.
+     */
+    export enum Charset { US_ASCII, UTF_8 }
+
+    /**
+     * Selector of Digest algorithm
+     */
+    export enum DigestAlgorithm { MD2, MD5, SHA_1, SHA_256, SHA_384, SHA_512 }
+
+    /**
+     * Selector of MAC algorithm
+     */
+    export enum MacAlgorithm { HMAC_MD5, HMAC_SHA_1, HMAC_SHA_256, HMAC_SHA_384, HMAC_SHA_512 }
+
+    /**
+     * This service provides utilities for string encoding/decoding, date formatting, JSON manipulation,
+     *  and other miscellaneous tasks.
+     */
+    export interface Utilities {
+      Charset: Charset
+      DigestAlgorithm: DigestAlgorithm
+      MacAlgorithm: MacAlgorithm
+      base64Decode(encoded: string): Byte[];
+      base64Decode(encoded: string, charset: Charset): Byte[];
+      base64DecodeWebSafe(encoded: string): Byte[];
+      base64DecodeWebSafe(encoded: string, charset: Charset): Byte[];
+      base64Encode(data: Byte[]): string;
+      base64Encode(data: string): string;
+      base64Encode(data: string, charset: Charset): string;
+      base64EncodeWebSafe(data: Byte[]): string;
+      base64EncodeWebSafe(data: string): string;
+      base64EncodeWebSafe(data: string, charset: Charset): string;
+      computeDigest(algorithm: DigestAlgorithm, value: string): Byte[];
+      computeDigest(algorithm: DigestAlgorithm, value: string, charset: Charset): Byte[];
+      computeHmacSha256Signature(value: string, key: string): Byte[];
+      computeHmacSha256Signature(value: string, key: string, charset: Charset): Byte[];
+      computeHmacSignature(algorithm: MacAlgorithm, value: string, key: string): Byte[];
+      computeHmacSignature(algorithm: MacAlgorithm, value: string, key: string, charset: Charset): Byte[];
+      computeRsaSha256Signature(value: string, key: string): Byte[];
+      computeRsaSha256Signature(value: string, key: string, charset: Charset): Byte[];
+      formatDate(date: Date, timeZone: string, format: string): string;
+      formatString(template: string, ...args: Object[]): string;
+      newBlob(data: Byte[]): Base.Blob;
+      newBlob(data: Byte[], contentType: string): Base.Blob;
+      newBlob(data: Byte[], contentType: string, name: string): Base.Blob;
+      newBlob(data: string): Base.Blob;
+      newBlob(data: string, contentType: string): Base.Blob;
+      newBlob(data: string, contentType: string, name: string): Base.Blob;
+      parseCsv(csv: string): String[][];
+      parseCsv(csv: string, delimiter: Char): String[][];
+      sleep(milliseconds: Integer): void;
+      unzip(blob: Base.BlobSource): Base.Blob[];
+      zip(blobs: Base.BlobSource[]): Base.Blob;
+      zip(blobs: Base.BlobSource[], name: string): Base.Blob;
+      jsonParse(jsonString: string): Object;
+      jsonStringify(obj: Object): string;
+    }
+
+  }
+}
+
+declare var Charset: GoogleAppsScript.Utilities.Charset;
+declare var DigestAlgorithm: GoogleAppsScript.Utilities.DigestAlgorithm;
+declare var MacAlgorithm: GoogleAppsScript.Utilities.MacAlgorithm;
+declare var Utilities: GoogleAppsScript.Utilities.Utilities;

google-apps-script/google-apps-script.xml-service.d.ts

@@ -0,0 +1,342 @@
+/// <reference path="google-apps-script.types.d.ts" />
+
+declare module GoogleAppsScript {
+  export module XML_Service {
+    /**
+     * A representation of an XML attribute.
+     * 
+     *      // Reads the first and last name of each person and adds a new attribute with the full name.
+     *      var xml = '<roster>'
+     *          + '<person first="John" last="Doe"/>'
+     *          + '<person first="Mary" last="Smith"/>'
+     *          + '</roster>';
+     *      var document = XmlService.parse(xml);
+     *      var people = document.getRootElement().getChildren('person');
+     *      for (var i = 0; i < people.length; i++) {
+     *        var person = people[i];
+     *        var firstName = person.getAttribute('first').getValue();
+     *        var lastName = person.getAttribute('last').getValue();
+     *        person.setAttribute('full', firstName + ' ' + lastName);
+     *      }
+     *      xml = XmlService.getPrettyFormat().format(document);
+     *      Logger.log(xml);
+     */
+    export interface Attribute {
+      getName(): string;
+      getNamespace(): Namespace;
+      getValue(): string;
+      setName(name: string): Attribute;
+      setNamespace(namespace: Namespace): Attribute;
+      setValue(value: string): Attribute;
+    }
+
+    /**
+     * A representation of an XML CDATASection node.
+     * 
+     *      // Create and log an XML document that shows how special characters like '<', '>', and '&' are 
+     *      // stored in a CDATASection node as compared to in a Text node.
+     *      var illegalCharacters = '<em>The Amazing Adventures of Kavalier & Clay</em>';
+     *      var cdata = XmlService.createCdata(illegalCharacters);
+     *      var text = XmlService.createText(illegalCharacters);
+     *      var root = XmlService.createElement('root').addContent(cdata).addContent(text);
+     *      var document = XmlService.createDocument(root);
+     *      var xml = XmlService.getPrettyFormat().format(document);
+     *      Logger.log(xml);
+     */
+    export interface Cdata {
+      append(text: string): Text;
+      detach(): Content;
+      getParentElement(): Element;
+      getText(): string;
+      getValue(): string;
+      setText(text: string): Text;
+    }
+
+    /**
+     * A representation of an XML Comment node.
+     */
+    export interface Comment {
+      detach(): Content;
+      getParentElement(): Element;
+      getText(): string;
+      getValue(): string;
+      setText(text: string): Comment;
+    }
+
+    /**
+     * A representation of a generic XML node.
+     * Implementing classes
+     * 
+     * NameBrief description
+     * 
+     * CdataA representation of an XML CDATASection node.
+     * 
+     * CommentA representation of an XML Comment node.
+     * 
+     * DocTypeA representation of an XML DocumentType node.
+     * 
+     * ElementA representation of an XML Element node.
+     * 
+     * EntityRefA representation of an XML EntityReference node.
+     * 
+     * ProcessingInstructionA representation of an XML ProcessingInstruction node.
+     * 
+     * TextA representation of an XML Text node.
+     */
+    export interface Content {
+      asCdata(): Cdata;
+      asComment(): Comment;
+      asDocType(): DocType;
+      asElement(): Element;
+      asEntityRef(): EntityRef;
+      asProcessingInstruction(): ProcessingInstruction;
+      asText(): Text;
+      detach(): Content;
+      getParentElement(): Element;
+      getType(): ContentType;
+      getValue(): string;
+    }
+
+    /**
+     * An enumeration representing the types of XML content nodes.
+     */
+    export enum ContentType { CDATA, COMMENT, DOCTYPE, ELEMENT, ENTITYREF, PROCESSINGINSTRUCTION, TEXT }
+
+    /**
+     * A representation of an XML DocumentType node.
+     */
+    export interface DocType {
+      detach(): Content;
+      getElementName(): string;
+      getInternalSubset(): string;
+      getParentElement(): Element;
+      getPublicId(): string;
+      getSystemId(): string;
+      getValue(): string;
+      setElementName(name: string): DocType;
+      setInternalSubset(data: string): DocType;
+      setPublicId(id: string): DocType;
+      setSystemId(id: string): DocType;
+    }
+
+    /**
+     * A representation of an XML document.
+     */
+    export interface Document {
+      addContent(content: Content): Document;
+      addContent(index: Integer, content: Content): Document;
+      cloneContent(): Content[];
+      detachRootElement(): Element;
+      getAllContent(): Content[];
+      getContent(index: Integer): Content;
+      getContentSize(): Integer;
+      getDescendants(): Content[];
+      getDocType(): DocType;
+      getRootElement(): Element;
+      hasRootElement(): boolean;
+      removeContent(): Content[];
+      removeContent(content: Content): boolean;
+      removeContent(index: Integer): Content;
+      setDocType(docType: DocType): Document;
+      setRootElement(element: Element): Document;
+    }
+
+    /**
+     * A representation of an XML Element node.
+     * 
+     *      // Adds up the values listed in a sample XML document and adds a new element with the total.
+     *      var xml = '<things>'
+     *          + '<plates>12</plates>'
+     *          + '<bowls>18</bowls>'
+     *          + '<cups>25</cups>'
+     *          + '</things>';
+     *      var document = XmlService.parse(xml);
+     *      var root = document.getRootElement();
+     *      var items = root.getChildren();
+     *      var total = 0;
+     *      for (var i = 0; i < items.length; i++) {
+     *        total += Number(items[i].getText());
+     *      }
+     *      var totalElement = XmlService.createElement('total').setText(total);
+     *      root.addContent(totalElement);
+     *      xml = XmlService.getPrettyFormat().format(document);
+     *      Logger.log(xml);
+     */
+    export interface Element {
+      addContent(content: Content): Element;
+      addContent(index: Integer, content: Content): Element;
+      cloneContent(): Content[];
+      detach(): Content;
+      getAllContent(): Content[];
+      getAttribute(name: string): Attribute;
+      getAttribute(name: string, namespace: Namespace): Attribute;
+      getAttributes(): Attribute[];
+      getChild(name: string): Element;
+      getChild(name: string, namespace: Namespace): Element;
+      getChildText(name: string): string;
+      getChildText(name: string, namespace: Namespace): string;
+      getChildren(): Element[];
+      getChildren(name: string): Element[];
+      getChildren(name: string, namespace: Namespace): Element[];
+      getContent(index: Integer): Content;
+      getContentSize(): Integer;
+      getDescendants(): Content[];
+      getDocument(): Document;
+      getName(): string;
+      getNamespace(): Namespace;
+      getNamespace(prefix: string): Namespace;
+      getParentElement(): Element;
+      getQualifiedName(): string;
+      getText(): string;
+      getValue(): string;
+      isAncestorOf(other: Element): boolean;
+      isRootElement(): boolean;
+      removeAttribute(attribute: Attribute): boolean;
+      removeAttribute(attributeName: string): boolean;
+      removeAttribute(attributeName: string, namespace: Namespace): boolean;
+      removeContent(): Content[];
+      removeContent(content: Content): boolean;
+      removeContent(index: Integer): Content;
+      setAttribute(attribute: Attribute): Element;
+      setAttribute(name: string, value: string): Element;
+      setAttribute(name: string, value: string, namespace: Namespace): Element;
+      setName(name: string): Element;
+      setNamespace(namespace: Namespace): Element;
+      setText(text: string): Element;
+    }
+
+    /**
+     * A representation of an XML EntityReference node.
+     */
+    export interface EntityRef {
+      detach(): Content;
+      getName(): string;
+      getParentElement(): Element;
+      getPublicId(): string;
+      getSystemId(): string;
+      getValue(): string;
+      setName(name: string): EntityRef;
+      setPublicId(id: string): EntityRef;
+      setSystemId(id: string): EntityRef;
+    }
+
+    /**
+     * A formatter for outputting an XML document, with three pre-defined formats that can be further
+     *  customized.
+     * 
+     *      // Log an XML document with specified formatting options.
+     *      var xml = '<root><a><b>Text!</b><b>More text!</b></a></root>';
+     *      var document = XmlService.parse(xml);
+     *      var output = XmlService.getCompactFormat()
+     *          .setLineSeparator('\n')
+     *          .setEncoding('UTF-8')
+     *          .setIndent('   ')
+     *          .format(document);
+     *      Logger.log(output);
+     */
+    export interface Format {
+      format(document: Document): string;
+      format(element: Element): string;
+      setEncoding(encoding: string): Format;
+      setIndent(indent: string): Format;
+      setLineSeparator(separator: string): Format;
+      setOmitDeclaration(omitDeclaration: boolean): Format;
+      setOmitEncoding(omitEncoding: boolean): Format;
+    }
+
+    /**
+     * A representation of an XML namespace.
+     */
+    export interface Namespace {
+      getPrefix(): string;
+      getURI(): string;
+    }
+
+    /**
+     * A representation of an XML ProcessingInstruction node.
+     */
+    export interface ProcessingInstruction {
+      detach(): Content;
+      getData(): string;
+      getParentElement(): Element;
+      getTarget(): string;
+      getValue(): string;
+    }
+
+    /**
+     * A representation of an XML Text node.
+     */
+    export interface Text {
+      append(text: string): Text;
+      detach(): Content;
+      getParentElement(): Element;
+      getText(): string;
+      getValue(): string;
+      setText(text: string): Text;
+    }
+
+    /**
+     * This service allows scripts to parse, navigate, and programmatically create XML documents.
+     * 
+     *      // Log the title and labels for the first page of blog posts on the Google Apps Developer blog.
+     *      function parseXml() {
+     *        var url = 'http://googleappsdeveloper.blogspot.com/atom.xml';
+     *        var xml = UrlFetchApp.fetch(url).getContentText();
+     *        var document = XmlService.parse(xml);
+     *        var root = document.getRootElement();
+     *        var atom = XmlService.getNamespace('http://www.w3.org/2005/Atom');
+     *      
+     *        var entries = document.getRootElement().getChildren('entry', atom);
+     *        for (var i = 0; i < entries.length; i++) {
+     *          var title = entries[i].getChild('title', atom).getText();
+     *          var categoryElements = entries[i].getChildren('category', atom);
+     *          var labels = [];
+     *          for (var j = 0; j < categoryElements.length; j++) {
+     *            labels.push(categoryElements[j].getAttribute('term').getValue());
+     *          }
+     *          Logger.log('%s (%s)', title, labels.join(', '));
+     *        }
+     *      }
+     *      
+     *      // Create and log an XML representation of the threads in your Gmail inbox.
+     *      function createXml() {
+     *        var root = XmlService.createElement('threads');
+     *        var threads = GmailApp.getInboxThreads();
+     *        for (var i = 0; i < threads.length; i++) {
+     *          var child = XmlService.createElement('thread')
+     *              .setAttribute('messageCount', threads[i].getMessageCount())
+     *              .setAttribute('isUnread', threads[i].isUnread())
+     *              .setText(threads[i].getFirstMessageSubject());
+     *          root.addContent(child);
+     *        }
+     *        var document = XmlService.createDocument(root);
+     *        var xml = XmlService.getPrettyFormat().format(document);
+     *        Logger.log(xml);
+     *      }
+     */
+    export interface XmlService {
+      ContentTypes: ContentType
+      createCdata(text: string): Cdata;
+      createComment(text: string): Comment;
+      createDocType(elementName: string): DocType;
+      createDocType(elementName: string, systemId: string): DocType;
+      createDocType(elementName: string, publicId: string, systemId: string): DocType;
+      createDocument(): Document;
+      createDocument(rootElement: Element): Document;
+      createElement(name: string): Element;
+      createElement(name: string, namespace: Namespace): Element;
+      createText(text: string): Text;
+      getCompactFormat(): Format;
+      getNamespace(uri: string): Namespace;
+      getNamespace(prefix: string, uri: string): Namespace;
+      getNoNamespace(): Namespace;
+      getPrettyFormat(): Format;
+      getRawFormat(): Format;
+      getXmlNamespace(): Namespace;
+      parse(xml: string): Document;
+    }
+
+  }
+}
+
+declare var XmlService: GoogleAppsScript.XML_Service.XmlService;