diff --git a/gapi.calendar/gapi.calendar-tests.ts b/gapi.calendar/gapi.calendar-tests.ts
new file mode 100644
index 0000000000..de335c6a15
--- /dev/null
+++ b/gapi.calendar/gapi.calendar-tests.ts
@@ -0,0 +1,152 @@
+/* Example taken from Google Calendar API JavaScript Quickstart https://developers.google.com/google-apps/calendar/quickstart/js */
+
+{
+  // Your Client ID can be retrieved from your project in the Google
+  // Developer Console, https://console.developers.google.com
+  var CLIENT_ID = '<YOUR_CLIENT_ID>';
+
+  var SCOPES = ["https://www.googleapis.com/auth/calendar.readonly"];
+
+  /**
+   * Check if current user has authorized this application.
+   */
+  function checkAuth() {
+    gapi.auth.authorize(
+      {
+        'client_id': CLIENT_ID,
+        'scope': SCOPES.join(' '),
+        'immediate': true
+      }, handleAuthResult);
+  }
+
+  /**
+   * Handle response from authorization server.
+   *
+   * @param {Object} authResult Authorization result.
+   */
+  function handleAuthResult(authResult: GoogleApiOAuth2TokenObject) {
+    var authorizeDiv = document.getElementById('authorize-div')!;
+    if (authResult && !authResult.error) {
+      // Hide auth UI, then load client library.
+      authorizeDiv.style.display = 'none';
+      loadCalendarApi();
+    } else {
+      // Show auth UI, allowing the user to initiate authorization by
+      // clicking authorize button.
+      authorizeDiv.style.display = 'inline';
+    }
+  }
+
+  /**
+   * Initiate auth flow in response to user clicking authorize button.
+   *
+   * @param {Event} event Button click event.
+   */
+  function handleAuthClick(event: MouseEvent) {
+    gapi.auth.authorize(
+      {client_id: CLIENT_ID, scope: SCOPES, immediate: false},
+      handleAuthResult);
+    return false;
+  }
+
+  /**
+   * Load Google Calendar client library. List upcoming events
+   * once client library is loaded.
+   */
+  function loadCalendarApi() {
+    gapi.client.load('calendar', 'v3', listUpcomingEvents);
+  }
+
+  /**
+   * Print the summary and start datetime/date of the next ten events in
+   * the authorized user's calendar. If no events are found an
+   * appropriate message is printed.
+   */
+  function listUpcomingEvents() {
+    var request = gapi.client.calendar.events.list({
+      'calendarId': 'primary',
+      'timeMin': (new Date()).toISOString(),
+      'showDeleted': false,
+      'singleEvents': true,
+      'maxResults': 10,
+      'orderBy': 'startTime'
+    });
+
+    request.execute(function(resp) {
+      var events = resp.items;
+      appendPre('Upcoming events:');
+
+      if (events.length > 0) {
+        for (let i = 0; i < events.length; i++) {
+          var event = events[i];
+          var when = event.start.dateTime;
+          if (!when) {
+            when = event.start.date;
+          }
+          appendPre(event.summary + ' (' + when + ')')
+        }
+      } else {
+        appendPre('No upcoming events found.');
+      }
+
+    });
+  }
+
+  /**
+   * Append a pre element to the body containing the given message
+   * as its text node.
+   *
+   * @param {string} message Text to be placed in pre element.
+   */
+  function appendPre(message: string) {
+    var pre = document.getElementById('output')!;
+    var textContent = document.createTextNode(message + '\n');
+    pre.appendChild(textContent);
+  }
+}
+
+/* Example taken from https://developers.google.com/google-apps/calendar/v3/reference/events/insert#examples */
+
+{
+  // Refer to the JavaScript quickstart on how to setup the environment:
+  // https://developers.google.com/google-apps/calendar/quickstart/js
+  // Change the scope to 'https://www.googleapis.com/auth/calendar' and delete any
+  // stored credentials.
+
+  const event = {
+    'summary': 'Google I/O 2015',
+    'location': '800 Howard St., San Francisco, CA 94103',
+    'description': 'A chance to hear more about Google\'s developer products.',
+    'start': {
+      'dateTime': '2015-05-28T09:00:00-07:00',
+      'timeZone': 'America/Los_Angeles'
+    },
+    'end': {
+      'dateTime': '2015-05-28T17:00:00-07:00',
+      'timeZone': 'America/Los_Angeles'
+    },
+    'recurrence': [
+      'RRULE:FREQ=DAILY;COUNT=2'
+    ],
+    'attendees': [
+      {'email': 'lpage@example.com'},
+      {'email': 'sbrin@example.com'}
+    ],
+    'reminders': {
+      'useDefault': false,
+      'overrides': [
+        {'method': 'email', 'minutes': 24 * 60},
+        {'method': 'popup', 'minutes': 10}
+      ]
+    }
+  };
+
+  var request = gapi.client.calendar.events.insert({
+    'calendarId': 'primary',
+    'resource': event
+  });
+
+  request.execute(function(event) {
+    appendPre('Event created: ' + event.htmlLink);
+  });
+}
diff --git a/gapi.calendar/index.d.ts b/gapi.calendar/index.d.ts
new file mode 100644
index 0000000000..bd0e3b0d17
--- /dev/null
+++ b/gapi.calendar/index.d.ts
@@ -0,0 +1,675 @@
+// Type definitions for Google Calendar API 3.0
+// Project: https://developers.google.com/google-apps/calendar/
+// Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="gapi" />
+
+declare namespace gapi.client.calendar {
+  export class freebusy {
+    static query(parameters: FreeBusyQueryParameters): HttpRequest<FreeBusy>;
+  }
+
+  interface FreeBusyQueryParameters {
+    timeMin: datetime;
+    timeMax: datetime;
+    timeZone?: string;
+    groupExpansionMax?: integer;
+    calendarExpansionMax?: integer;
+    items: {id: string}[];
+  }
+
+  interface FreeBusy {
+    kind: 'calendar#freeBusy';
+    timeMin: datetime;
+    timeMax: datetime;
+    groups: {
+      (key: string): {
+        errors?: {
+          domain: string;
+          reason: string;
+        }[];
+        calendars: string[];
+      }
+    };
+    calendars: {
+      (key: string): {
+        errors?: {
+          domain: string;
+          reason: string;
+        }[];
+        busy: {
+          start: datetime;
+          end: datetime;
+        }[];
+      }
+    };
+  }
+
+  export class acl {
+    static insert(parameters: AclInsertParameters): HttpRequest<Acl>;
+    static get(parameters: AclGetParameters): HttpRequest<Acl>;
+    static update(parameters: AclUpdateParameters): HttpRequest<Acl>;
+    static delete(parameters: AclDeleteParameters): HttpRequest<void>;
+  }
+
+  // The type of the scope. Possible values are:
+  type ScopeType =
+    // The public scope. This is the default value.
+    // Note: The permissions granted to the "default", or public, scope apply to any user, authenticated or not.
+    'default' |
+    // Limits the scope to a single user.
+    'user' |
+    // Limits the scope to a group.
+    'group' |
+    // Limits the scope to a domain.
+    'domain';
+
+  interface Acl {
+    kind: 'calendar#aclRule';
+    etag: etag;
+    id: string;
+    scope: {
+      type: ScopeType;
+      value: string;
+    };
+    role: AccessRole;
+  }
+
+  interface AclInsertParameters {
+    calendarId: string;
+
+    // Acl resource
+    role: AccessRole;
+    scope: {
+      type: ScopeType;
+      value?: string;
+    };
+  }
+
+  interface AclGetParameters {
+    calendarId: string;
+    ruleId: string;
+  }
+
+  interface AclUpdateParameters extends AclInsertParameters {
+    ruleId: string;
+  }
+
+  interface AclDeleteParameters extends AclGetParameters {
+  }
+
+  export class calendarList {
+    static list(parameters?: CalendarListListParameters): HttpRequest<CalendarList>;
+    static insert(parameters: CalendarListInsertParameters): HttpRequest<CalendarListEntry>;
+  }
+
+  type AccessRoleWithoutNone =
+    // The user has read access to free/busy information.
+    'freeBusyReader' |
+    // The user has read access to the calendar. Private events will appear to users with reader access, but event details will be hidden.
+    'reader' |
+    // The user has read and write access to the calendar. Private events will appear to users with writer access, and event details will be visible.
+    'writer' |
+    // The user has ownership of the calendar. This role has all of the permissions of the writer role with the additional ability to see and manipulate ACLs.
+    'owner';
+
+  // The user's access role for this calendar. Read-only. Possible values are:
+  type AccessRole =
+    // The user has no access.
+    'none' |
+    AccessRoleWithoutNone;
+
+  interface CalendarListListParameters {
+    maxResults?: integer;
+    // The minimum access role for the user in the returned entries. Optional. The default is no restriction. Acceptable values are:
+    minAccessRole?: AccessRoleWithoutNone;
+    pageToken?: string;
+    showDeleted?: boolean;
+    showHidden?: boolean;
+    syncToken?: string;
+  }
+
+  interface CalendarListInsertParameters {
+    // Parameters
+    // Optional query parameters
+    colorRgbFormat?: boolean;
+
+    // CalendarList resource
+    resource: CalendarListInput;
+  }
+
+  interface CalendarListInput {
+    // Required Properties
+    id: string;
+
+    // Optional Properties
+    backgroundColor?: string;
+    colorId?: string;
+    defaultReminders?: {
+      method: ReminderMethod;
+      minutes: integer;
+    }[];
+    foregroundColor?: string;
+    hidden?: boolean;
+    notificationSettings?: {
+      notifications: {
+        type: NotificationType;
+        method: string;
+      }[];
+    };
+    selected?: boolean;
+    summaryOverride?: string;
+  }
+
+  interface CalendarList {
+    kind: 'calendar#calendarList';
+    etag: etag;
+
+    /**
+     * Token used to access the next page of this result.
+     * Omitted if no further results are available, in which case nextSyncToken is provided.
+     */
+    nextPageToken?: string;
+
+    /**
+     * Token used at a later point in time to retrieve only the entries that have changed since this result was returned.
+     * Omitted if further results are available, in which case nextPageToken is provided.
+     */
+    nextSyncToken?: string;
+
+    items: CalendarListEntry[];
+  }
+
+  // The type of notification. Possible values are:
+  type NotificationType =
+    // Notification sent when a new event is put on the calendar.
+    'eventCreation' |
+    // Notification sent when an event is changed.
+    'eventChange' |
+    // Notification sent when an event is cancelled.
+    'eventCancellation' |
+    // Notification sent when an event is changed.
+    'eventResponse' |
+    // An agenda with the events of the day (sent out in the morning).
+    'agenda';
+
+  interface CalendarListEntry {
+    kind: 'calendar#calendarListEntry';
+    etag: etag;
+    id: string;
+    summary: string;
+    description?: string;
+    location?: string;
+    timeZone?: string;
+    summaryOverride?: string;
+    colorId?: string;
+    backgroundColor?: string;
+    foregroundColor?: string;
+    hidden?: boolean;
+    selected?: boolean;
+    // The effective access role that the authenticated user has on the calendar. Read-only.
+    accessRole: AccessRoleWithoutNone;
+    defaultReminders: {
+      method: ReminderMethod;
+      minutes: integer;
+    }[];
+    notificationSettings?: {
+      notifications: {
+        type: NotificationType;
+        method: string;
+      }[];
+    };
+    primary?: boolean;
+    deleted?: boolean;
+  }
+
+  export class calendars {
+    static insert(parameters: CalendarsInsertParameters): HttpRequest<Calendar>;
+    static update(parameters: CalendarsUpdateParameters): HttpRequest<Calendar>;
+    static delete(parameters: CalendarsDeleteParameters): HttpRequest<void>;
+  }
+
+  interface CalendarsUpdateParameters {
+    calendarId: string;
+
+    // Calendars resource
+    // Optional Properties
+    description?: string;
+    location?: string;
+    summary?: string;
+    timeZone?: string;
+  }
+
+  interface CalendarsInsertParameters {
+    // Calendars resource
+    // Required Properties
+    summary: string;
+
+    description?: string;
+    location?: string;
+    timeZone?: string;
+  }
+
+  interface CalendarsDeleteParameters {
+    calendarId: string;
+  }
+
+  interface Calendar {
+    kind: 'calendar#calendar';
+    etag: etag;
+    id: string;
+    summary: string;
+    description?: string;
+    location?: string;
+    timeZone?: string;
+  }
+
+  export class events {
+    static list(parameters: EventsListParameters): HttpRequest<Events>;
+    static insert(parameters: EventsInsertParameters): HttpRequest<Event>;
+    static update(parameters: EventsUpdateParameters): HttpRequest<Event>;
+    static get(parameters: EventsGetParameters): HttpRequest<Event>;
+  }
+
+  interface EventsGetParameters {
+    calendarId: string;
+    eventId: string;
+
+    alwaysIncludeEmail?: boolean;
+    maxAttendees?: integer;
+    timeZone?: string;
+  }
+
+  interface EventsInsertParameters {
+    calendarId: string;
+
+    maxAttendees?: integer;
+    sendNotifications?: boolean;
+    supportsAttachments?: boolean;
+
+    // Event resource
+    resource: EventInput;
+  }
+
+  interface EventsUpdateParameters {
+    calendarId: string;
+    eventId: string;
+
+    alwaysIncludeEmail?: boolean;
+    maxAttendees?: integer;
+    sendNotifications?: boolean;
+    supportsAttachments?: boolean;
+
+    // Event resource
+    resource: EventInput;
+  }
+
+  interface EventInput {
+    // Required Properties
+    attachments?: {
+      fileUrl: string;
+    }[];
+    attendees?: {
+      email: string;
+      displayName?: string;
+      optional?: boolean;
+      responseStatus?: AttendeeResponseStatus;
+      comment?: string;
+      additionalGuests?: integer;
+    }[];
+    end: {
+      date?: date;
+      dateTime?: datetime;
+      timeZone?: string
+    };
+    reminders?: {
+      overrides: {
+        method: string;
+        minutes: integer;
+      }[];
+      useDefault: boolean;
+    };
+    start: {
+      date?: date;
+      dateTime?: datetime;
+      timeZone: string;
+    };
+
+    // Optional Properties
+    anyoneCanAddSelf?: boolean;
+    colorId?: string;
+    description?: string;
+    extendedProperties?: {
+      private: {
+        (key: string): string
+      };
+      shared: {
+        (key: string): string
+      }
+    };
+    gadget?: {
+      display?: GadgetDisplayMode;
+      height: integer;
+      iconLink: string;
+      link: string;
+      preferences: {
+        (key: string): string
+      }
+      title: string;
+      type: string;
+      width: integer;
+    };
+    guestsCanInviteOthers?: boolean;
+    guestsCanSeeOtherGuests?: boolean;
+    id?: string;
+    location?: string;
+    originalStartTime?: {
+      date: date;
+      dateTime: datetime;
+      timeZone: string
+    };
+    recurrence?: string[];
+    sequence?: integer;
+    source?: {
+      url: string;
+      title: string
+    };
+    status?: EventStatus;
+    summary?: string;
+    transparency?: EventTransparency;
+    visibility?: EventVisibility;
+  }
+
+  // The order of the events returned in the result. Optional. The default is an unspecified, stable order.
+  // Acceptable values are:
+  type EventsOrder =
+    // Order by the start date/time (ascending). This is only available when querying single events (i.e. the parameter singleEvents is True)
+    'startTime' |
+    // Order by last modification time (ascending).
+    'updated';
+
+  // Token obtained from the nextSyncToken field returned on the last page of results from the previous list request.
+  // It makes the result of this list request contain only entries that have changed since then.
+  // All events deleted since the previous list request will always be in the result set and it is not allowed to set showDeleted to False.
+  // There are several query parameters that cannot be specified together with nextSyncToken to ensure consistency of the client state.
+  // These are:
+  type SyncToken =
+    'iCalUID' |
+    'orderBy' |
+    'privateExtendedProperty' |
+    'q' |
+    'sharedExtendedProperty' |
+    'timeMin' |
+    'timeMax' |
+    'updatedMin';
+
+  interface EventsListParameters {
+    calendarId: string;
+    alwaysIncludeEmail?: boolean;
+    iCalUID?: string;
+    maxAttendees?: integer;
+    maxResults?: integer;
+    orderBy?: EventsOrder;
+    pageToken?: string;
+    privateExtendedProperty?: string;
+    q?: string;
+    sharedExtendedProperty?: string;
+    showDeleted?: boolean;
+    showHiddenInvitations?: boolean;
+    singleEvents?: boolean;
+    syncToken?: SyncToken;
+    timeMax?: datetime;
+    timeMin?: datetime;
+    timeZone?: string;
+    updatedMin?: datetime;
+  }
+
+  interface Events {
+    kind: 'calendar#events';
+    etag: etag;
+    summary: string;
+    description: string;
+    updated: datetime;
+    timeZone: string;
+    // The user's access role for this calendar. Read-only. Possible values are:
+    accessRole: AccessRole;
+    defaultReminders: {
+      method: ReminderMethod;
+      minutes: integer;
+    }[];
+    nextPageToken?: string;
+    nextSyncToken?: string;
+    items: Event[];
+  }
+
+  type etag = string;
+  type datetime = string;
+  type date = string;
+  type integer = number;
+
+  // The attendee's response status. Possible values are:
+  type AttendeeResponseStatus =
+    // The attendee has not responded to the invitation.
+    'needsAction' |
+    // The attendee has declined the invitation.
+    'declined' |
+    // The attendee has tentatively accepted the invitation.
+    'tentative' |
+    // The attendee has accepted the invitation.
+    'accepted';
+
+  // The gadget's display mode. Optional. Possible values are:
+  type GadgetDisplayMode =
+    // The gadget displays next to the event's title in the calendar view.
+    'icon' |
+    // The gadget displays when the event is clicked.
+    'chip';
+
+  // The method used by this reminder. Possible values are:
+  type ReminderMethod =
+    // Reminders are sent via email.
+    'email' |
+    // Reminders are sent via SMS. These are only available for Google Apps for Work, Education, and Government customers. Requests to set SMS reminders for other account types are ignored.
+    'sms' |
+    // Reminders are sent via a UI popup.
+    'popup';
+
+  // Status of the event. Optional. Possible values are:
+  type EventStatus =
+    // The event is confirmed. This is the default status.
+    'confirmed' |
+    // The event is tentatively confirmed.
+    'tentative' |
+    // The event is cancelled.
+    'cancelled';
+
+  // Whether the event blocks time on the calendar. Optional. Possible values are:
+  type EventTransparency =
+    // The event blocks time on the calendar. This is the default value.
+    'opaque' |
+    // The event does not block time on the calendar.
+    'transparent';
+
+  // Visibility of the event. Optional. Possible values are:
+  type EventVisibility =
+    // Uses the default visibility for events on the calendar. This is the default value.
+    'default' |
+    // The event is public and event details are visible to all readers of the calendar.
+    'public' |
+    // The event is private and only event attendees may view event details.
+    'private' |
+    // The event is private. This value is provided for compatibility reasons.
+    'confidential';
+
+  class Event {
+    kind: 'calendar#event';
+    etag: etag;
+    id: string;
+    status?: EventStatus;
+    htmlLink: string;
+    created: datetime;
+    updated: datetime;
+    summary: string;
+    description: string;
+    location?: string;
+    colorId?: string;
+
+    // The creator of the event. Read-only.
+    creator: {
+      // The creator's Profile ID, if available.
+      id?: string;
+
+      // The creator's email address, if available.
+      email?: string;
+
+      // The creator's name, if available.
+      displayName?: string;
+
+      // Whether the creator corresponds to the calendar on which this copy of the event appears. Read-only. The default is False.
+      self?: boolean;
+    };
+
+    // The organizer of the event.
+    organizer: {
+      // The organizer's Profile ID, if available.
+      id?: string;
+
+      // The organizer's email address, if available.
+      email?: string;
+
+      // The organizer's name, if available.
+      displayName?: string;
+
+      // Whether the organizer corresponds to the calendar on which this copy of the event appears. Read-only. The default is False.
+      self?: boolean;
+    };
+
+    // The (inclusive) start time of the event. For a recurring event, this is the start time of the first instance.
+    start: {
+      // The date, in the format "yyyy-mm-dd", if this is an all-day event.
+      date?: date;
+
+      // The time, as a combined date-time value (formatted according to RFC3339).
+      // A time zone offset is required unless a time zone is explicitly specified in timeZone.
+      dateTime?: datetime;
+
+      // The time zone in which the time is specified. (Formatted as an IANA Time Zone Database name, e.g. "Europe/Zurich".)
+      // For recurring events this field is required and specifies the time zone in which the recurrence is expanded.
+      // For single events this field is optional and indicates a custom time zone for the event start/end.
+      timeZone?: string;
+    };
+
+    // The (exclusive) end time of the event. For a recurring event, this is the end time of the first instance.
+    end: {
+      // The date, in the format "yyyy-mm-dd", if this is an all-day event.
+      date?: date;
+
+      // The time, as a combined date-time value (formatted according to RFC3339).
+      // A time zone offset is required unless a time zone is explicitly specified in timeZone.
+      dateTime?: datetime;
+
+      // The time zone in which the time is specified. (Formatted as an IANA Time Zone Database name, e.g. "Europe/Zurich".)
+      // For recurring events this field is required and specifies the time zone in which the recurrence is expanded.
+      // For single events this field is optional and indicates a custom time zone for the event start/end.
+      timeZone?: string;
+    };
+
+    // 	Whether the end time is actually unspecified. An end time is still provided for compatibility reasons, even if this attribute is set to True.
+    // The default is False.
+    endTimeUnspecified?: boolean;
+
+    recurrence: string[];
+
+    // For an instance of a recurring event, this is the id of the recurring event to which this instance belongs. Immutable.
+    recurringEventId?: string;
+
+    // Whether the organizer corresponds to the calendar on which this copy of the event appears. Read-only. The default is False.
+    originalStartTime?: {
+      date: date;
+      dateTime: datetime;
+      timeZone?: string;
+    };
+
+    transparency?: EventTransparency;
+    visibility?: EventVisibility;
+    iCalUID: string;
+    sequence: integer;
+
+    // The attendees of the event.
+    attendees?: {
+      id: string;
+      email: string;
+      displayName?: string;
+      organizer: boolean;
+      self: boolean;
+      resource: boolean;
+      optional?: boolean;
+      responseStatus: AttendeeResponseStatus;
+      comment?: string;
+      additionalGuests?: integer;
+    }[];
+
+    attendeesOmitted?: boolean;
+
+    // Extended properties of the event.
+    extendedProperties?: {
+      private: {
+        (key: string): string;
+      };
+      shared: {
+        (key: string): string;
+      }
+    };
+
+    // An absolute link to the Google+ hangout associated with this event. Read-only.
+    hangoutLink?: string;
+
+    // A gadget that extends this event.
+    gadget?: {
+      type: string;
+      title: string;
+      link: string;
+      iconLink: string;
+      width?: integer;
+      height?: integer;
+      display?: GadgetDisplayMode;
+      preferences: {
+        (key: string): string;
+      }
+    };
+
+    anyoneCanAddSelf?: boolean;
+    guestsCanInviteOthers?: boolean;
+    guestsCanModify?: boolean;
+    guestsCanSeeOtherGuests?: boolean;
+    privateCopy?: boolean;
+
+    // Whether this is a locked event copy where no changes can be made to the main event fields "summary", "description", "location", "start", "end" or "recurrence". The default is False. Read-Only.
+    locked?: boolean;
+
+    reminders: {
+      useDefault: boolean;
+      overrides?: {
+        method: ReminderMethod;
+        minutes: integer;
+      }[];
+    };
+
+    // Source from which the event was created. For example, a web page, an email message or any document identifiable by an URL with HTTP or HTTPS scheme.
+    // Can only be seen or modified by the creator of the event.
+    source?: {
+      url: string;
+      title: string;
+    };
+
+    // File attachments for the event. Currently only Google Drive attachments are supported.
+    attachments?: {
+      fileUrl: string;
+      title: string;
+      mimeType: string;
+      iconLink: string;
+      fileId: string;
+    }[];
+  }
+}
diff --git a/gapi.calendar/tsconfig.json b/gapi.calendar/tsconfig.json
new file mode 100644
index 0000000000..7613ee5b3d
--- /dev/null
+++ b/gapi.calendar/tsconfig.json
@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "baseUrl": "../",
+    "typeRoots": ["../"],
+    "types": [],
+    "module": "commonjs",
+    "lib": ["es6", "dom"],
+    "strictNullChecks": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true
+  },
+  "files": [
+    "index.d.ts",
+    "gapi.calendar-tests.ts"
+  ]
+}