diff --git a/types/inboxsdk/inboxsdk-tests.ts b/types/inboxsdk/inboxsdk-tests.ts
new file mode 100644
index 0000000000..a763674c73
--- /dev/null
+++ b/types/inboxsdk/inboxsdk-tests.ts
@@ -0,0 +1,815 @@
+import ComposeView = InboxSDK.Compose.ComposeView;
+import Contact = InboxSDK.Common.Contact;
+import ThreadRowView = InboxSDK.Lists.ThreadRowView;
+import ThreadView = InboxSDK.Conversations.ThreadView;
+import SimpleElementView = InboxSDK.Common.SimpleElementView;
+import ContentPanelView = InboxSDK.Conversations.ContentPanelView;
+import MessageView = InboxSDK.Conversations.MessageView;
+import AttachmentCardView = InboxSDK.Conversations.AttachmentCardView;
+import AttachmentCardClickEvent = InboxSDK.Conversations.AttachmentCardClickEvent;
+import MessageViewLinkDescriptor = InboxSDK.Conversations.MessageViewLinkDescriptor;
+import SectionDescriptor = InboxSDK.Router.SectionDescriptor;
+import NavItemDescriptor = InboxSDK.NavMenu.NavItemDescriptor;
+
+InboxSDK.load(1, '1234').then((_sdk: InboxSDK.InboxSDKInstance) => {
+  _sdk.ButterBar.hideGmailMessage();
+});
+
+InboxSDK.load(1, '1234', {}).then(() => console.log('done'));
+InboxSDK.load(1, '1234', {
+  appIconUrl: 'url',
+  appName: 'name',
+  suppressAddonTitle: 'su'
+}).then(() => console.log('done'));
+
+InboxSDK.loadScript('https://google.com').then(() => console.log('done'));
+InboxSDK.loadScript('https://google.com', {}).then(() => console.log('done'));
+InboxSDK.loadScript('https://google.com', {nowrap: true}).then(() => console.log('done'));
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  sdk.ButterBar.showMessage({
+    text: 'text',
+  });
+
+  sdk.ButterBar.showMessage({
+    text: 'text',
+    className: 'c',
+    hideOnViewChanged: true,
+    persistent: true,
+    priority: 1,
+    time: 1,
+    messageKey: '1'
+  });
+
+  const el: HTMLElement = new HTMLElement();
+
+  sdk.ButterBar.showMessage({
+    el,
+  });
+
+  sdk.ButterBar.showMessage({
+    el,
+    className: 'c',
+    hideOnViewChanged: true,
+    persistent: true,
+    priority: 1,
+    time: 1,
+    messageKey: '1'
+  });
+
+  sdk.ButterBar.showMessage({
+    html: '<p></p>',
+  });
+
+  sdk.ButterBar.showMessage({
+    html: '<p></p>',
+    className: 'c',
+    hideOnViewChanged: true,
+    persistent: true,
+    priority: 1,
+    time: 1,
+    messageKey: '1'
+  });
+
+  sdk.ButterBar.showLoading();
+
+  sdk.ButterBar.showError({
+    text: 'error'
+  });
+
+  sdk.ButterBar.showSaving({
+    text: 'saving'
+  });
+
+  sdk.ButterBar.hideMessage('key');
+  sdk.ButterBar.hideGmailMessage();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const unregister = sdk.Compose.registerComposeViewHandler((composeView: ComposeView) => {
+    composeView.addButton({
+      title: 'button title',
+      onClick: e => {
+        const eq = e.composeView === composeView;
+        const dropdownDestroyed = e.dropdown.destroyed;
+
+        e.dropdown.close();
+
+        const el: HTMLElement = e.dropdown.el;
+
+        e.dropdown.setPlacementOptions({});
+        e.dropdown.setPlacementOptions({
+          bottomBuffer: 1,
+          buffer: 1,
+          forceHAlign: true,
+          forcePosition: true,
+          forceVAlign: true,
+          hAlign: 'center',
+          position: 'middle',
+          rightBuffer: 1,
+          topBuffer: 1,
+          vAlign: 'top',
+          leftBuffer: 1
+        });
+      }
+    });
+
+    const statusBarView = composeView.addStatusBar({});
+    statusBarView.setHeight(1);
+
+    composeView.addStatusBar({
+      height: 1,
+      orderHint: 1
+    });
+
+    composeView.close();
+
+    composeView.send();
+    composeView.send({sendAndArchive: true});
+
+    const element: HTMLElement = composeView.getBodyElement();
+    const msgId: string = composeView.getInitialMessageID();
+    const threadId: string = composeView.getThreadID();
+    composeView.getDraftID().then(draftId => {
+      const id: string = draftId.toLowerCase();
+    });
+    composeView.getCurrentDraftID().then(draftId => {
+      if (draftId) {
+        const id: string = draftId.toLowerCase();
+      }
+    });
+
+    const html: string = composeView.getHTMLContent();
+    const bodyHtml: string = composeView.getSelectedBodyHTML();
+    const bodyText: string = composeView.getSelectedBodyText();
+    const subject: string = composeView.getSubject();
+    const textContent: string = composeView.getTextContent();
+    const contacts: Contact[] = composeView.getToRecipients();
+    const contactsCC: Contact[] = composeView.getCcRecipients();
+    const contactsBCC: Contact[] = composeView.getBccRecipients();
+
+    composeView.insertTextIntoBodyAtCursor('text');
+    const el1: HTMLElement = composeView.insertHTMLIntoBodyAtCursor(new HTMLElement());
+    const el2: HTMLElement = composeView.insertHTMLIntoBodyAtCursor('html');
+
+    const el3: HTMLElement = composeView.insertLinkChipIntoBodyAtCursor('text', 'http://url.com', 'http://url.com/favicon.ico');
+    const el4: HTMLElement = composeView.insertLinkIntoBodyAtCursor('text', 'http://url.com');
+
+    const inline: boolean = composeView.isInlineReplyForm();
+    const fullScreen: boolean = composeView.isFullscreen();
+    const minimized: boolean = composeView.isMinimized();
+    composeView.setFullscreen(true);
+    composeView.setMinimized(true);
+    composeView.popOut().then(view => view === composeView);
+
+    const removeColor = composeView.setTitleBarColor('red');
+    removeColor();
+
+    const isReply: boolean = composeView.isReply();
+
+    composeView.setToRecipients(['a@a.com', 'b@b.com']);
+    composeView.setCcRecipients(['a@a.com', 'b@b.com']);
+    composeView.setBccRecipients(['a@a.com', 'b@b.com']);
+
+    const fromContact: InboxSDK.Common.Contact = composeView.getFromContact();
+    const fromContacts: InboxSDK.Common.Contact[] = composeView.getFromContactChoices();
+
+    composeView.setFromEmail('a@a.com');
+    composeView.setSubject('subject');
+    composeView.setBodyHTML('<p></p>');
+    composeView.setBodyText('text');
+    composeView.attachFiles([new Blob()]).then(() => console.log());
+    composeView.attachInlineFiles([new Blob()]).then(() => console.log());
+
+    composeView.on('destroy', event => {
+      const msgId: string = event.messageID;
+      const byInbox: boolean = event.closedByInboxSDK;
+    });
+
+    composeView.on('fullscreenChanged', event => {
+      const fs: boolean = event.fullscreen;
+    });
+
+    composeView.on('fromContactChanged', event => {
+      const c: InboxSDK.Common.Contact = event.contact;
+    });
+
+    composeView.on('toContactAdded', event => {
+      const c: InboxSDK.Common.Contact = event.contact;
+    });
+
+    composeView.on('toContactRemoved', event => {
+      const c: InboxSDK.Common.Contact = event.contact;
+    });
+
+    composeView.on('ccContactAdded', event => {
+      const c: InboxSDK.Common.Contact = event.contact;
+    });
+
+    composeView.on('ccContactRemoved', event => {
+      const c: InboxSDK.Common.Contact = event.contact;
+    });
+
+    composeView.on('bccContactAdded', event => {
+      const c: InboxSDK.Common.Contact = event.contact;
+    });
+
+    composeView.on('bccContactRemoved', event => {
+      const c: InboxSDK.Common.Contact = event.contact;
+    });
+
+    composeView.on('recipientsChanged', event => {
+      let c: InboxSDK.Common.Contact;
+      c = event.to.added[0];
+      c = event.to.removed[0];
+      c = event.cc.added[0];
+      c = event.cc.removed[0];
+      c = event.bcc.added[0];
+      c = event.bcc.removed[0];
+    });
+
+    composeView.on('presending', event => {
+      event.cancel();
+    });
+
+    composeView.on('sent', event => {
+      event.getMessageID().then(msgId => msgId.toLowerCase());
+      event.getThreadID().then(threadId => threadId.toLowerCase());
+    });
+
+    composeView.on('discard', () => {
+      console.log();
+    });
+    composeView.on('sendCanceled', () => {
+      console.log();
+    });
+    composeView.on('sending', () => {
+      console.log();
+    });
+    composeView.on('bodyChanged', () => {
+      console.log();
+    });
+    composeView.on('minimized', () => {
+      console.log();
+    });
+    composeView.on('restored', () => {
+      console.log();
+    });
+
+    const destroyed: boolean = composeView.destroyed;
+  });
+
+  unregister();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const unregister = sdk.Lists.registerThreadRowViewHandler((threadRowView: ThreadRowView) => {
+    threadRowView.addLabel({
+      title: 'title',
+      iconUrl: 'http://url.com'
+    });
+
+    threadRowView.addLabel({
+      title: 'title',
+      iconUrl: 'http://url.com',
+      backgroundColor: 'red',
+      foregroundColor: 'blue',
+      iconBackgroundColor: 'yellow',
+      iconClass: 'big'
+    });
+
+    threadRowView.addImage({
+      imageUrl: 'http://url.com'
+    });
+
+    threadRowView.addImage({
+      imageUrl: 'http://url.com',
+      imageClass: 'big',
+      tooltip: 'tooltip',
+      orderHint: 1
+    });
+
+    threadRowView.addButton({
+      title: 'title',
+      iconUrl: 'http://url.com',
+      onClick: event => {
+        const eq = event.threadRowView === threadRowView;
+        if (event.dropdown) {
+          event.dropdown.close();
+        }
+      },
+      hasDropdown: true
+    });
+
+    threadRowView.addButton({
+      title: 'title',
+      iconUrl: 'http://url.com',
+      onClick: event => {
+      },
+      hasDropdown: false,
+      iconClass: 'big'
+    });
+
+    threadRowView.addActionButton({
+      type: 'LINK',
+      title: 'title',
+      className: 'big',
+      url: 'http://url.com',
+      onClick: () => {
+      }
+    });
+
+    threadRowView.addAttachmentIcon({});
+    threadRowView.addAttachmentIcon({
+      tooltip: 'tooltip',
+      iconClass: 'big',
+      iconUrl: 'http://url.com'
+    });
+
+    threadRowView.replaceDate({
+      text: '1/1/2000'
+    });
+    threadRowView.replaceDate({
+      text: '1/1/2000',
+      textColor: 'red',
+      tooltip: 'tooltip'
+    });
+
+    threadRowView.replaceDraftLabel({
+      text: 'my draft'
+    });
+    threadRowView.replaceDraftLabel({
+      text: 'my draft',
+      count: '2'
+    });
+
+    const subject: string = threadRowView.getSubject();
+    const date: string = threadRowView.getDateString();
+    threadRowView.getThreadIDAsync().then(threadId => threadId.toLowerCase());
+    threadRowView.getThreadIDIfStableAsync().then(threadId => {
+      if (threadId) {
+        threadId.toLowerCase();
+      }
+    });
+    threadRowView.getDraftID().then(draftId => draftId.toLowerCase());
+
+    const count1: number = threadRowView.getVisibleDraftCount();
+    const count2: number = threadRowView.getVisibleMessageCount();
+
+    const contacts: InboxSDK.Common.Contact[] = threadRowView.getContacts();
+
+    threadRowView.on('destroyed', () => console.log());
+
+    const destroyed: boolean = threadRowView.destroyed;
+  });
+
+  unregister();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const unregister = sdk.Conversations.registerThreadViewHandler((threadView: ThreadView) => {
+    const noticeBar: SimpleElementView = threadView.addNoticeBar();
+    noticeBar.destroy();
+
+    const contentPanel: ContentPanelView = threadView.addSidebarContentPanel({
+      el: new HTMLElement(),
+      title: 'title',
+      iconUrl: 'http://url.com',
+    });
+
+    contentPanel.remove();
+    const destroyed: boolean = contentPanel.destroyed;
+    contentPanel.on('destroy', () => console.log());
+    contentPanel.on('deactivate', () => console.log());
+    contentPanel.on('activate', () => console.log());
+
+    threadView.addSidebarContentPanel({
+      el: new HTMLElement(),
+      title: 'title',
+      iconUrl: 'http://url.com',
+      appIconUrl: 'http://url.com',
+      appName: 'app name',
+      id: '1',
+      orderHint: 1,
+      hideTitleBar: true
+    });
+
+    const messageViews: MessageView[] = threadView.getMessageViews();
+    const allMessageViews: MessageView[] = threadView.getMessageViewsAll();
+    const subject: string = threadView.getSubject();
+    threadView.getThreadIDAsync().then(threadId => threadId.toLowerCase());
+
+    threadView.on('contactHover', event => {
+      const contact: Contact = event.contact;
+      const eq1 = event.messageView === messageViews[0];
+      const eq2 = event.threadView === threadView;
+      const isSender: boolean = event.contactType === 'sender';
+    });
+
+    threadView.on('destroy', () => console.log());
+  });
+
+  unregister();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const unregister = sdk.Conversations.registerMessageViewHandler((messageView: MessageView) => {
+    const attachmentCardView: AttachmentCardView = messageView.addAttachmentCardView({
+      title: 'title',
+      description: 'desc',
+      previewUrl: 'http://url.com',
+      previewThumbnailUrl: 'http://url.com',
+      failoverPreviewIconUrl: 'http://url.com',
+      previewOnClick: event => {
+        const eq = event.attachmentCardView === attachmentCardView;
+        event.preventDefault();
+      },
+      fileIconImageUrl: 'http://url.com',
+      buttons: [
+        {
+          downloadUrl: 'http://url.com',
+          downloadFilename: 'file.txt',
+          openInNewTab: true,
+          onClick: () => {
+          }
+        },
+        {
+          iconUrl: 'http://url.com',
+          tooltip: 'tooltip',
+          onClick: (event: AttachmentCardClickEvent) => event.getDownloadURL().then(url => url.toLowerCase())
+        }
+      ],
+      foldColor: 'red',
+      mimeType: 'text'
+    });
+
+    const attachmentType: string = attachmentCardView.getAttachmentType();
+    const title: string = attachmentCardView.getTitle();
+    const msgView: MessageView | null = attachmentCardView.getMessageView();
+    attachmentCardView.addButton({
+      iconUrl: 'http://url.com',
+      tooltip: 'tooltip',
+      onClick: (event: AttachmentCardClickEvent) => event.getDownloadURL().then(url => url.toLowerCase())
+    });
+
+    attachmentCardView.on('destroy', () => console.log());
+    const destroyed: boolean = attachmentCardView.destroyed;
+
+    messageView.addAttachmentsToolbarButton({
+      iconUrl: 'http://url.com',
+      tooltip: 'tooltip',
+      onClick: event => {
+        const attType: string = event.attachmentCardViews[0].getAttachmentType();
+      }
+    });
+
+    messageView.addToolbarButton({
+      section: 'MORE',
+      title: 'title',
+      iconUrl: 'http://url.com',
+      iconClass: 'big',
+      onClick: () => {
+      },
+      orderHint: 1
+    });
+
+    const el: HTMLElement = messageView.getBodyElement();
+    messageView.getMessageIDAsync().then(msgId => msgId.toLowerCase());
+    const attCardViews: AttachmentCardView[] = messageView.getFileAttachmentCardViews();
+    const isQuotedArea = messageView.isElementInQuotedArea();
+    const isLoaded = messageView.isLoaded();
+    const links: MessageViewLinkDescriptor[] = messageView.getLinksInBody();
+    links[0].text.toLowerCase();
+    links[0].element.click();
+    links[0].html.toLowerCase();
+    const isInQuotedArea: boolean = links[0].isInQuotedArea;
+    links[0].href.toLowerCase();
+
+    const contact: Contact = messageView.getSender();
+    const add: string[] = messageView.getRecipientEmailAddresses();
+    messageView.getRecipientsFull().then(contacts => {
+      const c: Contact = contacts[0];
+    });
+
+    const threadView: ThreadView = messageView.getThreadView();
+    const date: string = messageView.getDateString();
+    messageView.addAttachmentIcon({
+      iconUrl: 'http://url.com',
+      iconClass: 'big',
+      onClick: () => {
+      },
+      tooltip: 'tooltip'
+    });
+
+    const eq = messageView.getViewState() === 'HIDDEN';
+
+    messageView.on('viewStateChange', event => {
+      const eq1 = event.newViewState === 'COLLAPSED';
+      const eq2 = event.oldViewState === 'EXPANDED';
+      const eq3 = event.messageView === messageView;
+    });
+
+    messageView.on('contactHover', event => {
+      event.contact.name.toLowerCase();
+    });
+
+    messageView.on('load', () => console.log());
+    messageView.on('destroy', () => console.log());
+
+    const destroyed1: boolean = messageView.destroyed;
+  });
+
+  unregister();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const unregister = sdk.Conversations.registerMessageViewHandlerAll((messageView: MessageView) => {
+    const isLoaded: boolean = messageView.isLoaded();
+  });
+
+  unregister();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const unregister = sdk.Conversations.registerFileAttachmentCardViewHandler((attachmentCardView: AttachmentCardView) => {
+    const messageView: MessageView | null = attachmentCardView.getMessageView();
+  });
+
+  unregister();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const unregister = sdk.Toolbars.registerThreadButton({
+    hasDropdown: true,
+    hideFor: (routeView => routeView.getParams()),
+    iconClass: 'big',
+    iconUrl: 'http://url.com',
+    keyboardShortcutHandle: {
+      remove: () => {
+      }
+    },
+    listSection: 'INBOX_STATE',
+    onClick: event => event.position === 'LIST',
+    orderHint: 1,
+    positions: ['LIST', 'ROW'],
+    threadSection: 'METADATA_STATE',
+    title: 'title'
+  });
+
+  unregister();
+
+  sdk.Toolbars.addToolbarButtonForApp({
+    iconClass: 'big',
+    arrowColor: 'red',
+    iconUrl: 'http://url.com',
+    onClick: event => event.dropdown.close(),
+    title: 'title',
+    titleClass: 'big'
+  });
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  sdk.Router.createLink('1234', {p1: 1, 0: 1}).toLowerCase();
+  sdk.Router.goto('1234', {p1: 1, 0: 1});
+
+  const unregister1 = sdk.Router.handleCustomRoute('1234', customRouteView => {
+    customRouteView.getParams();
+    customRouteView.setFullWidth(true);
+    customRouteView.getElement().click();
+  });
+
+  unregister1();
+
+  const unregister2 = sdk.Router.handleAllRoutes(routeView => {
+    routeView.getParams();
+    routeView.getRouteID();
+    routeView.getRouteType();
+    routeView.on('destroy', () => {
+    });
+    const destroyed: boolean = routeView.destroyed;
+  });
+
+  unregister2();
+
+  const unregister3 = sdk.Router.handleListRoute('ALL_MAIL', listRouteView => {
+    const sectionDescriptor: SectionDescriptor = {
+      contentElement: new HTMLElement(),
+      footerLinkText: 'text',
+      hasDropdown: true,
+      onDropdownClick: event => event.dropdown.close(),
+      onFooterLinkClick: event => {
+      },
+      onTitleLinkClick: () => {
+      },
+      subtitle: 'title',
+      tableRows: [{
+        body: 'body',
+        iconClass: 'big',
+        iconUrl: 'http://url.com',
+        isRead: 'true',
+        labels: [{
+          iconClass: 'big',
+          iconBackgroundColor: 'red',
+          foregroundColor: 'green',
+          backgroundColor: 'blue',
+          iconUrl: 'http://url.com',
+          title: 'title'
+        }],
+        onClick: () => {
+        },
+        routeID: '1234',
+        routeParams: ['p1'],
+        shortDetailText: 'text',
+        title: 'title'
+      }],
+      title: 'title',
+      titleLinkText: 'text'
+    };
+
+    listRouteView.addCollapsibleSection(sectionDescriptor);
+    listRouteView.addSection(sectionDescriptor);
+
+    listRouteView.refresh();
+  });
+
+  unregister3();
+
+  const unregister4 = sdk.Router.handleCustomListRoute('1234', (offset, max) => {
+    return {
+      threads: [
+        {
+          rfcMessageId: 'id',
+          gmailThreadId: 'id'
+        },
+        'id'
+      ],
+      total: 1,
+      hasMore: true,
+    };
+  });
+
+  unregister4();
+
+  sdk.Router.getCurrentRouteView().getRouteID().toLowerCase();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const navItemDescriptor: NavItemDescriptor = {
+    accessory: {
+      type: 'CREATE',
+      onClick: () => {
+      }
+    },
+    backgroundColor: 'red',
+    expanderForegroundColor: 'green',
+    iconClass: 'big',
+    iconUrl: 'http://url.com',
+    name: 'name',
+    onClick: event => event.preventDefault(),
+    orderHint: 1,
+    routeID: '1234',
+    routeParams: {p: 1},
+    type: 'MANAGE'
+  };
+
+  const navItem = sdk.NavMenu.addNavItem(navItemDescriptor);
+  const navItem1 = navItem.addNavItem(navItemDescriptor);
+  navItem.remove();
+  navItem1.remove();
+
+  const isCollapsed: boolean = navItem.isCollapsed();
+  navItem.setCollapsed(true);
+
+  navItem.on('destroy', () => {
+  });
+  const destroyed: boolean = navItem.destroyed;
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const modalView = sdk.Widgets.showModalView({
+    buttons: [{
+      color: 'red',
+      onClick: () => {
+      },
+      orderHint: 1,
+      text: 'text',
+      title: 'title',
+      type: 'PRIMARY_ACTION'
+    }],
+    chrome: true,
+    constrainTitleWidth: true,
+    el: new HTMLElement(),
+    showCloseButton: true,
+    title: 'title'
+  });
+
+  modalView.close();
+  modalView.on('destroyed', () => {
+  });
+  const destroyed: boolean = modalView.destroyed;
+
+  const moleView = sdk.Widgets.showMoleView({
+    chrome: true,
+    className: 'big',
+    el: new HTMLElement(),
+    minimizedTitleEl: new HTMLElement(),
+    title: 'title',
+    titleEl: new HTMLElement(),
+    titleButtons: [{
+      iconClass: 'big',
+      iconUrl: 'http://url.com',
+      onClick: () => {
+      },
+      title: 'title'
+    }]
+  });
+
+  moleView.close();
+  const minimized: boolean = moleView.getMinimized();
+  moleView.setMinimized(true);
+  moleView.setTitle('title');
+  moleView.on('destroyed', () => {
+  });
+  moleView.on('minimize', () => {
+  });
+  moleView.on('restore', () => {
+  });
+
+  const drawerView = sdk.Widgets.showDrawerView({
+    chrome: true,
+    closeWithCompose: true,
+    el: new HTMLElement(),
+    title: 'title'
+  });
+
+  drawerView.close();
+  drawerView.disassociateComposeView();
+  const destroyed1: boolean = drawerView.destroyed;
+  drawerView.on('destroyed', () => {
+  });
+  drawerView.on('slideAnimationDone', () => {
+  });
+  drawerView.on('closing', () => {
+  });
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const searchResults = [{
+    iconUrl: 'http://url.com',
+    onClick: () => {
+    },
+    description: 'desc',
+    externalURL: 'http://url.com',
+    name: 'name',
+    routeName: 'name',
+    routeParams: ['a', 'b']
+  }, {
+    iconUrl: 'http://url.com',
+    onClick: () => {
+    },
+    descriptionHTML: 'desc',
+    externalURL: 'http://url.com',
+    nameHTML: 'name',
+    routeName: 'name',
+    routeParams: ['a', 'b']
+  }];
+
+  sdk.Search.registerSearchSuggestionsProvider(query => searchResults);
+  sdk.Search.registerSearchSuggestionsProvider(query => Promise.resolve(searchResults));
+
+  sdk.Search.registerSearchQueryRewriter({
+    term: 'a',
+    termReplacer: () => 'b'
+  });
+
+  sdk.Search.registerSearchQueryRewriter({
+    term: 'a',
+    termReplacer: () => Promise.resolve('b')
+  });
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  sdk.User.getEmailAddress().toLowerCase();
+  const isConversationViewDisabled: boolean = sdk.User.isConversationViewDisabled();
+  const isUsingGmailMaterialUI: boolean = sdk.User.isUsingGmailMaterialUI();
+  sdk.User.getLanguage().toLowerCase();
+  sdk.User.getAccountSwitcherContactList()[0].name.toLowerCase();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const panel = sdk.Global.addSidebarContentPanel({
+    el: new HTMLElement(),
+    title: 'title',
+    iconUrl: 'http://url.com'
+  });
+  panel.remove();
+});
+
+InboxSDK.load(1, '1234').then((sdk: InboxSDK.InboxSDKInstance) => {
+  const handler = sdk.Keyboard.createShortcutHandle({
+    chord: 'a',
+    description: 'b'
+  });
+
+  handler.remove();
+});
diff --git a/types/inboxsdk/index.d.ts b/types/inboxsdk/index.d.ts
new file mode 100644
index 0000000000..66b696e05a
--- /dev/null
+++ b/types/inboxsdk/index.d.ts
@@ -0,0 +1,1073 @@
+// Type definitions for InboxSDK 2.0
+// Project: https://www.inboxsdk.com/
+// Definitions by: Raphaël Doursenaud <https://github.com/rdoursenaud>
+//                 Amiram Korach <https://github.com/amiram>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
+
+/*
+ * Copyright (c) 2016 GPC.solutions
+ * Copyright (c) 2018 https://propelmypr.com
+ */
+
+// tslint:disable-next-line:export-just-namespace
+export = InboxSDK;
+export as namespace InboxSDK;
+
+declare namespace InboxSDK {
+  function load(version: number, appId?: string, opts?: LoadOptions): Promise<InboxSDKInstance>;
+
+  function loadScript(url: string, options?: LoadScriptOptions): Promise<void>;
+
+// // Undocummented
+// var IMPL_VERSION: string;
+// var LOADER_VERSION: string;
+// var destroyed: boolean; //: false
+// var Logger: {
+//   error: () => any;
+//   event: () => any;
+// };
+
+  interface LoadOptions {
+    appName?: string;
+    appIconUrl?: string;
+    suppressAddonTitle?: string;
+  }
+
+  interface LoadScriptOptions {
+    nowrap?: boolean;
+  }
+
+  interface InboxSDKInstance {
+    Compose: Compose.ComposeInstance;
+    Lists: Lists.ListsInstance;
+    Conversations: Conversations.ConversationsInstance;
+    Toolbars: Toolbars.ToolbarsInstance;
+    Router: Router.RouterInstance;
+    NavMenu: NavMenu.NavMenuInstance;
+    Widgets: Widgets.WidgetsInstance;
+    ButterBar: ButterBar.ButterBarInstance;
+    Search: Search.SearchInstance;
+    User: User.UserInstance;
+    Keyboard: Keyboard.KeyboardInstance;
+    Global: Global.GlobalInstance;
+  }
+
+  namespace Common {
+    interface Contact {
+      name: string;
+      emailAddress: string;
+    }
+
+    interface DropdownView {
+      setPlacementOptions(options: PositionOptions): void;
+
+      close(): void;
+
+      reposition(): void;
+
+      el: HTMLElement;
+      destroyed: boolean;
+
+      on(name: 'destroy', cb: () => void): void;
+
+      on(name: 'preautoclose', cb: (event: PreAutoCloseEvent) => void): void;
+    }
+
+    interface PreAutoCloseEvent {
+      type: 'outsideInteraction' | 'escape';
+      cause: Event;
+
+      cancel(): void;
+    }
+
+    interface PositionOptions {
+      position?: string;
+      forcePosition?: boolean;
+      hAlign?: string;
+      forceHAlign?: boolean;
+      vAlign?: string;
+      forceVAlign?: boolean;
+      buffer?: number;
+      topBuffer?: number;
+      bottomBuffer?: number;
+      leftBuffer?: number;
+      rightBuffer?: number;
+    }
+
+    interface SimpleElementView {
+      destroy(): void;
+
+      el: HTMLElement;
+      destroyed: boolean;
+
+      on(name: 'destroy', cb: () => void): void;
+    }
+  }
+
+  export namespace Compose {
+    interface ComposeInstance {
+      registerComposeViewHandler(handler: (composeView: ComposeView) => void): () => void;
+
+      openNewComposeView(): Promise<ComposeView>;
+    }
+
+    interface ComposeView {
+      addButton(buttonDescriptor: ComposeButtonDescriptor): void;
+
+      addStatusBar(statusBarDescriptor: StatusBarDescriptor): StatusBarView;
+
+      close(): void;
+
+      send(options?: SendOptions): void;
+
+      getBodyElement(): HTMLElement;
+
+      getInitialMessageID(): string;
+
+      getThreadID(): string;
+
+      getDraftID(): Promise<string>;
+
+      getCurrentDraftID(): Promise<string | null>;
+
+      getHTMLContent(): string;
+
+      getSelectedBodyHTML(): string;
+
+      getSelectedBodyText(): string;
+
+      getSubject(): string;
+
+      getTextContent(): string;
+
+      getToRecipients(): Common.Contact[];
+
+      getCcRecipients(): Common.Contact[];
+
+      getBccRecipients(): Common.Contact[];
+
+      insertTextIntoBodyAtCursor(text: string): void;
+
+      insertHTMLIntoBodyAtCursor(html: string | HTMLElement): HTMLElement;
+
+      insertLinkChipIntoBodyAtCursor(text: string, url: string, iconUrl: string): HTMLElement;
+
+      insertLinkIntoBodyAtCursor(text: string, url: string): HTMLElement;
+
+      isInlineReplyForm(): boolean;
+
+      isFullscreen(): boolean;
+
+      setFullscreen(minimized: boolean): void;
+
+      isMinimized(): boolean;
+
+      setMinimized(minimized: boolean): void;
+
+      popOut(): Promise<ComposeView>;
+
+      setTitleBarColor(color: string): () => void;
+
+      isReply(): boolean;
+
+      setToRecipients(emails: string[]): void;
+
+      setCcRecipients(emails: string[]): void;
+
+      setBccRecipients(emails: string[]): void;
+
+      getFromContact(): Common.Contact;
+
+      getFromContactChoices(): Common.Contact[];
+
+      setFromEmail(email: string): void;
+
+      setSubject(text: string): void;
+
+      setBodyHTML(html: string): void;
+
+      setBodyText(text: string): void;
+
+      attachFiles(files: Blob[]): Promise<void>;
+
+      attachInlineFiles(Files: Blob[]): Promise<void>;
+
+      on(name: 'destroy', cb: (event: { messageID: string, closedByInboxSDK: boolean }) => void): void;
+
+      on(name: 'fullscreenChanged', cb: (event: { fullscreen: boolean }) => void): void;
+
+      on(name: 'fromContactChanged' | 'toContactAdded' | 'toContactRemoved' | 'ccContactAdded' | 'ccContactRemoved' | 'bccContactAdded' | 'bccContactRemoved',
+         cb: (event: { contact: Common.Contact }) => void): void;
+
+      on(name: 'recipientsChanged', cb: (event: RecipientsChangedEvent) => void): void;
+
+      on(name: 'presending', cb: (event: { cancel: () => void }) => void): void;
+
+      on(name: 'sent', cb: (event: { getThreadID: () => Promise<string>, getMessageID: () => Promise<string> }) => void): void;
+
+      on(name: 'discard' | 'sendCanceled' | 'sending' | 'bodyChanged' | 'minimized' | 'restored', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface RecipientsChangedEvent {
+      to: {
+        added: Common.Contact[];
+        removed: Common.Contact[];
+      };
+      cc: {
+        added: Common.Contact[];
+        removed: Common.Contact[];
+      };
+      bcc: {
+        added: Common.Contact[];
+        removed: Common.Contact[];
+      };
+    }
+
+    interface ComposeButtonDescriptor {
+      title: string;
+      iconUrl?: string;
+      iconClass?: string;
+      onClick: (event: ComposeButtonClickEvent) => void;
+      hasDropdown?: boolean;
+      type?: 'MODIFIER' | 'SEND_ACTION';
+      orderHint?: number;
+      enabled?: boolean;
+    }
+
+    interface ComposeButtonClickEvent {
+      composeView: ComposeView;
+      dropdown: Common.DropdownView;
+    }
+
+    interface StatusBarDescriptor {
+      height?: number;
+      orderHint?: number;
+    }
+
+    interface StatusBarView extends Common.SimpleElementView {
+      setHeight(height: number): void;
+    }
+
+    interface SendOptions {
+      sendAndArchive?: boolean;
+    }
+  }
+
+  export namespace Lists {
+    interface ListsInstance {
+      registerThreadRowViewHandler(handler: (threadRowView: ThreadRowView) => any): () => void;
+    }
+
+    interface ThreadRowView {
+      addLabel(labelDescriptor: LabelDescriptor): void;
+
+      // addLabel(labelDescriptor: Stream<LabelDescriptor>): void;
+
+      addImage(imageDescriptor: ImageDescriptor): void;
+
+      // addImage(imageDescriptor: Stream<ImageDescriptor>): void;
+
+      addButton(buttonDescriptor: ThreadRowButtonDescriptor): void;
+
+      // addButton(buttonDescriptor: Stream<ThreadRowButtonDescriptor>): void;
+
+      addActionButton(buttonDescriptor: ThreadRowActionButtonDescriptor): void;
+
+      // addActionButton(buttonDescriptor: Stream<ThreadRowActionButtonDescriptor>): void;
+
+      addAttachmentIcon(threadRowAttachmentIconDescriptor: ThreadRowAttachmentIconDescriptor): void;
+
+      // addAttachmentIcon(threadRowAttachmentIconDescriptor: stream<ThreadRowAttachmentIconDescriptor>): void
+
+      replaceDate(threadRowDateDescriptor: ThreadRowDateDescriptor): void;
+
+      // replaceDate(threadRowDateDescriptor: Stream<ThreadRowDateDescriptor>): void;
+
+      replaceDraftLabel(draftLabelDescriptor: ThreadRowDraftLabelDescriptor): void;
+
+      // replaceDraftLabel(draftLabelDescriptor: Stream<ThreadRowDraftLabelDescriptor>): void;
+
+      getSubject(): string;
+
+      getDateString(): string;
+
+      getThreadIDAsync(): Promise<string>;
+
+      getThreadIDIfStableAsync(): Promise<string | null>;
+
+      getDraftID(): Promise<string>;
+
+      getVisibleDraftCount(): number;
+
+      getVisibleMessageCount(): number;
+
+      getContacts(): Common.Contact[];
+
+      on(name: 'destroyed', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface ThreadRowButtonDescriptor {
+      title: string;
+      iconUrl: string;
+      iconClass?: string;
+      onClick: (event: ThreadRowButtonClickEvent) => void;
+      hasDropdown?: boolean;
+    }
+
+    interface ThreadRowButtonClickEvent {
+      threadRowView: ThreadRowView;
+      dropdown?: Common.DropdownView;
+    }
+
+    interface ThreadRowActionButtonDescriptor {
+      type: 'LINK';
+      title: string;
+      className?: string;
+      onClick?: (event: any) => void;
+      url: string;
+    }
+
+    interface LabelDescriptor {
+      title: string;
+      foregroundColor?: string;
+      backgroundColor?: string;
+      iconUrl: string;
+      iconClass?: string;
+      iconBackgroundColor?: string;
+    }
+
+    interface ImageDescriptor {
+      imageUrl: string;
+      imageClass?: string;
+      tooltip?: string;
+      orderHint?: number;
+    }
+
+    interface ThreadRowDateDescriptor {
+      text: string;
+      textColor?: string;
+      tooltip?: string;
+    }
+
+    interface ThreadRowAttachmentIconDescriptor {
+      iconUrl?: string;
+      iconClass?: string;
+      tooltip?: string;
+    }
+
+    interface ThreadRowDraftLabelDescriptor {
+      text: string;
+      count?: string;
+    }
+  }
+
+  export namespace Conversations {
+    interface ConversationsInstance {
+      registerThreadViewHandler(handler: (threadView: ThreadView) => void): () => void;
+
+      registerMessageViewHandler(handler: (messageView: MessageView) => void): () => void;
+
+      registerMessageViewHandlerAll(handler: (messageView: MessageView) => void): () => void;
+
+      registerFileAttachmentCardViewHandler(handler: (attachmentCardView: AttachmentCardView) => void): () => void;
+    }
+
+    interface ThreadView {
+      addNoticeBar(): Common.SimpleElementView;
+
+      addSidebarContentPanel(contentPanelDescriptor: ContentPanelDescriptor): ContentPanelView;
+
+      getMessageViews(): MessageView[];
+
+      getMessageViewsAll(): MessageView[];
+
+      getSubject(): string;
+
+      getThreadIDAsync(): Promise<string>;
+
+      on(name: 'contactHover', cb: (event: ContactHoverEvent) => void): void;
+
+      on(name: 'destroy', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface ContactHoverEvent {
+      contact: Common.Contact;
+      contactType: 'sender' | 'recipient';
+      messageView: MessageView;
+      threadView: ThreadView;
+    }
+
+    interface MessageView {
+      addAttachmentCardView(cardOptions: AttachmentCardOptions | AttachmentCardNoPreviewOptions): AttachmentCardView;
+
+      addAttachmentsToolbarButton(buttonOptions: AttachmentsToolbarButtonDescriptor): void;
+
+      addToolbarButton(options: MessageViewToolbarButtonDescriptor): void;
+
+      getBodyElement(): HTMLElement;
+
+      getMessageIDAsync(): Promise<string>;
+
+      getFileAttachmentCardViews(): AttachmentCardView[];
+
+      isElementInQuotedArea(): boolean;
+
+      isLoaded(): boolean;
+
+      getLinksInBody(): MessageViewLinkDescriptor[];
+
+      getSender(): Common.Contact;
+
+      getRecipientEmailAddresses(): string[];
+
+      getRecipientsFull(): Promise<Common.Contact[]>;
+
+      getThreadView(): ThreadView;
+
+      getDateString(): string;
+
+      addAttachmentIcon(iconDescriptor: MessageAttachmentIconDescriptor): void;
+
+      // addAttachmentIcon(iconDescriptor: Stream<MessageAttachmentIconDescriptor>): void;
+
+      getViewState(): MessageViewViewStates;
+
+      on(name: 'viewStateChange', cb: (event: { newViewState: MessageViewViewStates, oldViewState: MessageViewViewStates, messageView: MessageView }) => void): void;
+
+      on(name: 'contactHover', cb: (event: ContactHoverEvent) => void): void;
+
+      on(name: 'destroy' | 'load', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    type MessageViewViewStates = 'HIDDEN' | 'COLLAPSED' | 'EXPANDED';
+
+    interface ContentPanelView {
+      remove(): void;
+
+      on(name: 'destroy' | 'activate' | 'deactivate', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface AttachmentCardView {
+      getAttachmentType(): string;
+
+      addButton(buttonDescriptor: CustomButtonDescriptor): void;
+
+      getTitle(): string;
+
+      /**
+       * @deprecated. Use AttachmentCardClickEvent.getDownloadURL() instead
+       */
+      getDownloadURL(): Promise<string>;
+
+      getMessageView(): MessageView | null;
+
+      on(name: 'destroy', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    // ConversationsDescriptors
+
+    interface AttachmentCardOptions {
+      title: string;
+      description: string;
+      previewUrl: string;
+      previewThumbnailUrl: string;
+      failoverPreviewIconUrl: string;
+      previewOnClick: (event: PreviewClickEvent) => void;
+      fileIconImageUrl: string;
+      buttons: Array<DownloadButtonDescriptor | CustomButtonDescriptor>;
+      foldColor?: string;
+      mimeType?: string;
+    }
+
+    interface AttachmentCardNoPreviewOptions {
+      title: string;
+      description: string;
+      previewUrl: string;
+      iconThumbnailUrl: string;
+      previewOnClick: (event: PreviewClickEvent) => void;
+      fileIconImageUrl: string;
+      buttons: Array<DownloadButtonDescriptor | CustomButtonDescriptor>;
+      foldColor?: string;
+    }
+
+    interface PreviewClickEvent {
+      attachmentCardView: AttachmentCardView;
+
+      preventDefault(): void;
+    }
+
+    interface ContentPanelDescriptor {
+      el: HTMLElement;
+      title: string;
+      iconUrl: string;
+      appName?: string;
+      appIconUrl?: string;
+      id?: string;
+      hideTitleBar?: boolean;
+      orderHint?: number;
+    }
+
+    interface DownloadButtonDescriptor {
+      downloadUrl: string;
+      downloadFilename?: string;
+      onClick: (event: any) => void;
+      openInNewTab?: boolean;
+    }
+
+    interface CustomButtonDescriptor {
+      iconUrl: string;
+      tooltip: string;
+      onClick: (event: AttachmentCardClickEvent) => void;
+    }
+
+    interface AttachmentCardClickEvent {
+      getDownloadURL(): Promise<string>;
+    }
+
+    interface AttachmentsToolbarButtonDescriptor {
+      tooltip: string;
+      iconUrl: string;
+      onClick: (event: AttachmentsToolbarButtonEvent) => void;
+    }
+
+    interface AttachmentsToolbarButtonEvent {
+      attachmentCardViews: AttachmentCardView[];
+    }
+
+    interface MessageViewLinkDescriptor {
+      text: string;
+      html: string;
+      element: HTMLElement;
+      href: string;
+      isInQuotedArea: boolean;
+    }
+
+    interface MessageAttachmentIconDescriptor {
+      iconUrl: string;
+      iconClass?: string;
+      tooltip: string;
+      onClick?: () => void;
+    }
+
+    interface MessageViewToolbarButtonDescriptor {
+      section: 'MORE';
+      title: string;
+      iconUrl: string;
+      onClick: () => void;
+      iconClass?: string;
+      orderHint: number;
+    }
+  }
+
+  export namespace Toolbars {
+    interface ToolbarsInstance {
+      registerThreadButton(toolbarButtonDescriptor: ToolbarButtonDescriptor): () => void;
+
+      /**
+       * @deprecated. use registerThreadButton
+       * @param toolbarButtonDescriptor
+       */
+      registerToolbarButtonForList(toolbarButtonDescriptor: ToolbarButtonDescriptor): () => void;
+
+      /**
+       * @deprecated. use registerThreadButton
+       * @param toolbarButtonDescriptor
+       */
+      registerToolbarButtonForThreadView(toolbarButtonDescriptor: ToolbarButtonDescriptor): () => void;
+
+      addToolbarButtonForApp(appToolbarButtonDescriptor: AppToolbarButtonDescriptor): AppToolbarButtonView;
+    }
+
+    interface ToolbarButtonDescriptor {
+      title: string;
+      onClick: (event: ToolbarButtonEvent) => void;
+      iconUrl?: string;
+      iconClass?: string;
+      positions?: ToolbarButtonPosition[];
+      threadSection?: SectionNames;
+      listSection?: SectionNames;
+      hasDropdown?: boolean;
+      hideFor?: (routeView: Router.RouteView) => void;
+      orderHint?: number;
+      keyboardShortcutHandle?: Keyboard.KeyboardShortcutHandle;
+    }
+
+    type ToolbarButtonPosition = 'THREAD' | 'ROW' | 'LIST';
+
+    interface ToolbarButtonEvent {
+      position: ToolbarButtonPosition;
+      selectedThreadRowViews: Lists.ThreadRowView[];
+      selectedThreadViews: Conversations.ThreadView[];
+      dropdown?: Common.DropdownView;
+    }
+
+    interface AppToolbarButtonDescriptor {
+      title: string;
+      titleClass?: string;
+      iconUrl: string;
+      iconClass?: string;
+      onClick: (event: AppToolbarButtonEvent) => void;
+      arrowColor?: string;
+    }
+
+    interface AppToolbarButtonView {
+      open(): void;
+
+      close(): void;
+
+      remove(): void;
+
+      on(name: 'destroy', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface AppToolbarButtonEvent {
+      dropdown: Common.DropdownView;
+    }
+
+    type SectionNames = 'INBOX_STATE' | 'METADATA_STATE' | 'OTHER';
+  }
+
+  export namespace Router {
+    interface RouterInstance {
+      createLink(routeID: string | NativeRouteIDs, params: RouteParams): string;
+
+      goto(routeID: string | NativeRouteIDs, params: RouteParams): void;
+
+      handleCustomRoute(routeID: string, handler: (customRouteView: CustomRouteView) => void): () => void;
+
+      handleAllRoutes(handler: (routeView: RouteView) => void): () => void;
+
+      handleListRoute(routeID: NativeListRouteIDs, handler: (listRouteView: ListRouteView) => void): () => void;
+
+      handleCustomListRoute(routeID: string, handler: (offset: number, max: number) => CustomListDescriptor | Promise<CustomListDescriptor>): () => void;
+
+      getCurrentRouteView(): RouteView;
+    }
+
+    interface CustomListDescriptor {
+      threads: Array<ThreadDescriptor | string>;
+      total?: number;
+      hasMore?: boolean;
+    }
+
+    interface ThreadDescriptor {
+      rfcMessageId?: string;
+      gmailThreadId?: string;
+    }
+
+    interface RouteParams {
+      [key: number]: string | number;
+
+      [key: string]: string | number;
+    }
+
+    interface RouteView {
+      getRouteID(): string;
+
+      getRouteType(): RouteTypes;
+
+      getParams(): RouteParams;
+
+      on(name: 'destroy', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    type RouteTypes = 'LIST' | 'THREAD' | 'SETTINGS' | 'CHAT' | 'CUSTOM' | 'UNKNOWN';
+
+    interface CustomRouteView extends RouteView {
+      getElement(): HTMLElement;
+
+      setFullWidth(fullWidth: boolean): void;
+    }
+
+    interface ListRouteView extends RouteView {
+      addCollapsibleSection(options: SectionDescriptor): CollapsibleSectionView;
+
+      // addCollapsibleSection(options: Stream<SectionDescriptor>): CollapsibleSectionView;
+
+      addSection(options: SectionDescriptor): SectionView;
+
+      // addSection(options: Stream<SectionDescriptor>): SectionView;
+
+      refresh(): void;
+    }
+
+    interface SectionView {
+      remove(): void;
+
+      on(name: 'destroy', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface CollapsibleSectionView extends SectionView {
+      setCollapsed(value: boolean): void;
+
+      remove(): void;
+
+      on(name: 'destroy' | 'expanded' | 'collapsed', cb: () => void): void;
+    }
+
+    interface SectionDescriptor {
+      title: string;
+      subtitle?: string;
+      titleLinkText?: string;
+      onTitleLinkClick?: () => void;
+      hasDropdown?: boolean;
+      onDropdownClick?: (event: SectionDropdownClickEvent) => void;
+      tableRows?: RowDescriptor[];
+      contentElement?: HTMLElement;
+      footerLinkText?: string;
+      onFooterLinkClick?: (event: any) => void;
+    }
+
+    interface SectionDropdownClickEvent {
+      dropdown: Common.DropdownView;
+    }
+
+    interface RowDescriptor {
+      title: string;
+      body: string;
+      shortDetailText: string;
+      isRead: string;
+      labels: Lists.LabelDescriptor[];
+      iconUrl?: string;
+      iconClass?: string;
+      routeID?: string;
+      routeParams?: string[];
+      onClick?: () => void;
+    }
+
+    type NativeRouteIDs =
+      'INBOX' |
+      'ALL_MAIL' |
+      'SENT' |
+      'STARRED' |
+      'DRAFTS' |
+      'SNOOZED' |
+      'DONE' |
+      'REMINDERS' |
+      'LABEL' |
+      'TRASH' |
+      'SPAM' |
+      'IMPORTANT' |
+      'SEARCH' |
+      'THREAD' |
+      'CHATS' |
+      'CHAT' |
+      'CONTACTS' |
+      'CONTACT' |
+      'SETTINGS' |
+      'ANY_LIST';
+
+    type NativeListRouteIDs =
+      'INBOX'
+      | 'ALL_MAIL'
+      | 'SENT'
+      | 'STARRED'
+      | 'DRAFTS'
+      | 'SNOOZED'
+      | 'DONE'
+      | 'REMINDERS'
+      | 'LABEL'
+      | 'TRASH'
+      | 'SPAM'
+      | 'IMPORTANT'
+      | 'SEARCH'
+      | 'ANY_LIST';
+  }
+
+  export namespace NavMenu {
+    interface NavMenuInstance {
+      addNavItem(navItemDescriptor: NavItemDescriptor): NavItemView;
+    }
+
+    interface NavItemView {
+      addNavItem(navItemDescriptor: NavItemDescriptor): NavItemView;
+
+      remove(): void;
+
+      isCollapsed(): boolean;
+
+      setCollapsed(collapseValue: boolean): void;
+
+      on(name: 'destroy', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface NavItemDescriptor {
+      name: string;
+      routeID?: string;
+      routeParams?: object;
+
+      onClick?: (event: { preventDefault(): void }) => void;
+
+      orderHint?: number;
+      accessory?: CreateAccessoryDescriptor | IconButtonAccessoryDescriptor | DropdownButtonAccessoryDescriptor;
+      iconUrl?: string;
+      iconClass?: string;
+      backgroundColor?: string;
+      expanderForegroundColor?: string;
+      type?: NavItemTypes;
+    }
+
+    interface CreateAccessoryDescriptor {
+      type: 'CREATE';
+      onClick: () => void;
+    }
+
+    interface IconButtonAccessoryDescriptor {
+      type: 'ICON_BUTTON';
+      onClick: () => void;
+      iconUrl: string;
+      iconClass?: string;
+    }
+
+    interface DropdownButtonAccessoryDescriptor {
+      type: 'DROPDOWN_BUTTON';
+      buttonBackgroundColor: string;
+      buttonForegroundColor: string;
+      onClick: (event: DropdownButtonClickEvent) => void;
+    }
+
+    interface DropdownButtonClickEvent {
+      dropdown: Common.DropdownView;
+    }
+
+    type NavItemTypes = 'MANAGE' | 'NAVIGATION';
+  }
+
+  export namespace Widgets {
+    interface WidgetsInstance {
+      showModalView(options: ModalOptions): ModalView;
+
+      showMoleView(options: MoleOptions): MoleView;
+
+      showDrawerView(options: DrawerOptions): DrawerView;
+    }
+
+    interface ModalOptions {
+      el: HTMLElement;
+      chrome?: boolean;
+      constrainTitleWidth?: boolean;
+      showCloseButton?: boolean;
+      title?: string;
+      buttons?: ModalButtonDescriptor[];
+    }
+
+    interface ModalButtonDescriptor {
+      text: string;
+      title: string;
+      onClick: () => void;
+      type?: 'PRIMARY_ACTION' | 'SECONDARY_ACTION';
+      color?: string;
+      orderHint?: number;
+    }
+
+    interface MoleOptions {
+      el: HTMLElement;
+      title?: string;
+      titleEl?: HTMLElement;
+      minimizedTitleEl?: HTMLElement;
+      className?: string;
+      titleButtons?: MoleButtonDescriptor[];
+      chrome?: boolean;
+    }
+
+    interface MoleButtonDescriptor {
+      title: string;
+      iconUrl: string;
+      iconClass?: string;
+      onClick: () => void;
+    }
+
+    interface DrawerOptions {
+      el: HTMLElement;
+      chrome?: boolean;
+      title?: string;
+      composeView?: Compose.ComposeView;
+      closeWithCompose?: boolean;
+    }
+
+    interface ModalView {
+      close(): void;
+
+      on(name: 'destroyed', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface MoleView {
+      close(): void;
+
+      setTitle(text: string): void;
+
+      setMinimized(minimized: boolean): void;
+
+      getMinimized(): boolean;
+
+      on(name: 'destroyed' | 'minimize' | 'restore', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+
+    interface DrawerView {
+      close(): void;
+
+      associateComposeView(composeView: Compose.ComposeView, closeWithCompose: boolean): void;
+
+      disassociateComposeView(): void;
+
+      on(name: 'destroyed' | 'slideAnimationDone' | 'closing', cb: () => void): void;
+
+      destroyed: boolean;
+    }
+  }
+
+  export namespace ButterBar {
+    interface ButterBarInstance {
+      showMessage(options: MessageDescriptor): object;
+
+      showLoading(): object;
+
+      showError(options: MessageDescriptor): object;
+
+      showSaving(options: SavingMessageDescriptor): object;
+
+      hideMessage(messageKey: object | string): void;
+
+      hideGmailMessage(): void;
+    }
+
+    interface MessageDescriptorBase {
+      className?: string;
+      priority?: number;
+      time?: number;
+      hideOnViewChanged?: boolean;
+      persistent?: boolean;
+      messageKey?: object | string;
+    }
+
+    interface MessageDescriptorText extends MessageDescriptorBase {
+      text: string;
+    }
+
+    interface MessageDescriptorHtml extends MessageDescriptorBase {
+      html: string;
+    }
+
+    interface MessageDescriptorHtmlElement extends MessageDescriptorBase {
+      el: HTMLElement;
+    }
+
+    type MessageDescriptor = MessageDescriptorText | MessageDescriptorHtml | MessageDescriptorHtmlElement;
+
+    interface SavingMessageDescriptorBase extends MessageDescriptorBase {
+      confirmationText?: string;
+      confirmationTime?: number;
+      showConfirmation?: boolean;
+    }
+
+    interface SavingMessageDescriptorText extends SavingMessageDescriptorBase {
+      text: string;
+    }
+
+    interface SavingMessageDescriptorHtml extends SavingMessageDescriptorBase {
+      html: string;
+    }
+
+    interface SavingMessageDescriptorHtmlElement extends SavingMessageDescriptorBase {
+      el: HTMLElement;
+    }
+
+    type SavingMessageDescriptor =
+      SavingMessageDescriptorText
+      | SavingMessageDescriptorHtml
+      | SavingMessageDescriptorHtmlElement;
+  }
+
+  export namespace Search {
+    interface SearchInstance {
+      registerSearchSuggestionsProvider(handler: (query: string) => AutocompleteSearchResult[] | Promise<AutocompleteSearchResult[]>): void;
+
+      registerSearchQueryRewriter(rewriter: SearchQueryRewriter): void;
+    }
+
+    interface AutocompleteSearchResultBase {
+      iconUrl?: string;
+      routeName?: string;
+      routeParams?: string[];
+      externalURL?: string;
+      onClick?: () => void;
+    }
+
+    interface AutocompleteSearchResultText extends AutocompleteSearchResultBase {
+      name: string;
+      description: string;
+    }
+
+    interface AutocompleteSearchResultHtml extends AutocompleteSearchResultBase {
+      nameHTML: string;
+      descriptionHTML: string;
+    }
+
+    type AutocompleteSearchResult = AutocompleteSearchResultText | AutocompleteSearchResultHtml;
+
+    interface SearchQueryRewriter {
+      term: string;
+      termReplacer: () => string | Promise<string>;
+    }
+  }
+
+  export namespace User {
+    interface UserInstance {
+      getEmailAddress(): string;
+
+      isUsingGmailMaterialUI(): boolean;
+
+      isConversationViewDisabled(): boolean;
+
+      getLanguage(): string;
+
+      getAccountSwitcherContactList(): Common.Contact[];
+    }
+  }
+
+  export namespace Keyboard {
+    interface KeyboardInstance {
+      createShortcutHandle(keyboardShortcutDescriptor: KeyboardShortcutDescriptor): KeyboardShortcutHandle;
+    }
+
+    interface KeyboardShortcutHandle {
+      remove(): void;
+    }
+
+    interface KeyboardShortcutDescriptor {
+      chord: string;
+      description: string;
+    }
+  }
+
+  export namespace Global {
+    interface GlobalInstance {
+      addSidebarContentPanel(contentPanelDescriptor: Conversations.ContentPanelDescriptor): Conversations.ContentPanelView;
+    }
+  }
+}
diff --git a/types/inboxsdk/tsconfig.json b/types/inboxsdk/tsconfig.json
new file mode 100644
index 0000000000..846443ce68
--- /dev/null
+++ b/types/inboxsdk/tsconfig.json
@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "inboxsdk-tests.ts"
+    ]
+}
diff --git a/types/inboxsdk/tslint.json b/types/inboxsdk/tslint.json
new file mode 100644
index 0000000000..99ea174f67
--- /dev/null
+++ b/types/inboxsdk/tslint.json
@@ -0,0 +1,6 @@
+{
+  "extends": "dtslint/dt.json",
+  "rules": {
+    "strict-export-declare-modifiers": false
+  }
+}