diff --git a/lib/elements/array-selector.d.ts b/lib/elements/array-selector.d.ts
new file mode 100644
index 0000000000..7151205058
--- /dev/null
+++ b/lib/elements/array-selector.d.ts
@@ -0,0 +1,190 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/elements/array-selector.html
+ */
+
+/// <reference path="../../polymer-element.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="../utils/array-splice.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element mixin for recording dynamic associations between item paths in a
+   * master `items` array and a `selected` array such that path changes to the
+   * master array (at the host) element or elsewhere via data-binding) are
+   * correctly propagated to items in the selected array and vice-versa.
+   *
+   * The `items` property accepts an array of user data, and via the
+   * `select(item)` and `deselect(item)` API, updates the `selected` property
+   * which may be bound to other parts of the application, and any changes to
+   * sub-fields of `selected` item(s) will be kept in sync with items in the
+   * `items` array.  When `multi` is false, `selected` is a property
+   * representing the last selected item.  When `multi` is true, `selected`
+   * is an array of multiply selected items.
+   */
+  function ArraySelectorMixin<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+
+      /**
+       * An array containing items from which selection will be made.
+       */
+      items: any[]|null;
+
+      /**
+       * When `true`, multiple items may be selected at once (in this case,
+       * `selected` is an array of currently selected items).  When `false`,
+       * only one item may be selected at a time.
+       */
+      multi: boolean;
+
+      /**
+       * When `multi` is true, this is an array that contains any selected.
+       * When `multi` is false, this is the currently selected item, or `null`
+       * if no item is selected.
+       */
+      selected: Object|Object[]|null;
+
+      /**
+       * When `multi` is false, this is the currently selected item, or `null`
+       * if no item is selected.
+       */
+      selectedItem: Object|null;
+
+      /**
+       * When `true`, calling `select` on an item that is already selected
+       * will deselect the item.
+       */
+      toggle: boolean;
+      __updateSelection(multi: any, itemsInfo: any): any;
+      __applySplices(splices: any): any;
+      __updateLinks(): any;
+
+      /**
+       * Clears the selection state.
+       */
+      clearSelection(): any;
+
+      /**
+       * Returns whether the item is currently selected.
+       *
+       * @param item Item from `items` array to test
+       * @returns Whether the item is selected
+       */
+      isSelected(item: any): boolean;
+
+      /**
+       * Returns whether the item is currently selected.
+       *
+       * @param idx Index from `items` array to test
+       * @returns Whether the item is selected
+       */
+      isIndexSelected(idx: number): boolean;
+      __deselectChangedIdx(idx: any): any;
+      __selectedIndexForItemIndex(idx: any): any;
+
+      /**
+       * Deselects the given item if it is already selected.
+       *
+       * @param item Item from `items` array to deselect
+       */
+      deselect(item: any): any;
+
+      /**
+       * Deselects the given index if it is already selected.
+       *
+       * @param idx Index from `items` array to deselect
+       */
+      deselectIndex(idx: number): any;
+
+      /**
+       * Selects the given item.  When `toggle` is true, this will automatically
+       * deselect the item if already selected.
+       *
+       * @param item Item from `items` array to select
+       */
+      select(item: any): any;
+
+      /**
+       * Selects the given index.  When `toggle` is true, this will automatically
+       * deselect the item if already selected.
+       *
+       * @param idx Index from `items` array to select
+       */
+      selectIndex(idx: number): any;
+    }
+  } & T
+
+  /**
+   * Element implementing the `Polymer.ArraySelector` mixin, which records
+   * dynamic associations between item paths in a master `items` array and a
+   * `selected` array such that path changes to the master array (at the host)
+   * element or elsewhere via data-binding) are correctly propagated to items
+   * in the selected array and vice-versa.
+   *
+   * The `items` property accepts an array of user data, and via the
+   * `select(item)` and `deselect(item)` API, updates the `selected` property
+   * which may be bound to other parts of the application, and any changes to
+   * sub-fields of `selected` item(s) will be kept in sync with items in the
+   * `items` array.  When `multi` is false, `selected` is a property
+   * representing the last selected item.  When `multi` is true, `selected`
+   * is an array of multiply selected items.
+   *
+   * Example:
+   *
+   * ```html
+   * <dom-module id="employee-list">
+   *
+   *   <template>
+   *
+   *     <div> Employee list: </div>
+   *     <template is="dom-repeat" id="employeeList" items="{{employees}}">
+   *         <div>First name: <span>{{item.first}}</span></div>
+   *         <div>Last name: <span>{{item.last}}</span></div>
+   *         <button on-click="toggleSelection">Select</button>
+   *     </template>
+   *
+   *     <array-selector id="selector" items="{{employees}}" selected="{{selected}}" multi toggle></array-selector>
+   *
+   *     <div> Selected employees: </div>
+   *     <template is="dom-repeat" items="{{selected}}">
+   *         <div>First name: <span>{{item.first}}</span></div>
+   *         <div>Last name: <span>{{item.last}}</span></div>
+   *     </template>
+   *
+   *   </template>
+   *
+   * </dom-module>
+   * ```
+   *
+   * ```js
+   * Polymer({
+   *   is: 'employee-list',
+   *   ready() {
+   *     this.employees = [
+   *         {first: 'Bob', last: 'Smith'},
+   *         {first: 'Sally', last: 'Johnson'},
+   *         ...
+   *     ];
+   *   },
+   *   toggleSelection(e) {
+   *     let item = this.$.employeeList.itemForElement(e.target);
+   *     this.$.selector.select(item);
+   *   }
+   * });
+   * ```
+   */
+  class ArraySelector extends
+    Polymer.ArraySelectorMixin(
+    Polymer.Element) {
+  }
+}
+
+interface HTMLElementTagNameMap {
+  "array-selector": Polymer.ArraySelector;
+}
diff --git a/lib/elements/custom-style.d.ts b/lib/elements/custom-style.d.ts
new file mode 100644
index 0000000000..3b983a99ad
--- /dev/null
+++ b/lib/elements/custom-style.d.ts
@@ -0,0 +1,72 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/elements/custom-style.html
+ */
+
+/// <reference path="../../../shadycss/custom-style-interface.d.ts" />
+/// <reference path="../utils/style-gather.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Custom element for defining styles in the main document that can take
+   * advantage of [shady DOM](https://github.com/webcomponents/shadycss) shims
+   * for style encapsulation, custom properties, and custom mixins.
+   *
+   * - Document styles defined in a `<custom-style>` are shimmed to ensure they
+   *   do not leak into local DOM when running on browsers without native
+   *   Shadow DOM.
+   * - Custom properties can be defined in a `<custom-style>`. Use the `html` selector
+   *   to define custom properties that apply to all custom elements.
+   * - Custom mixins can be defined in a `<custom-style>`, if you import the optional
+   *   [apply shim](https://github.com/webcomponents/shadycss#about-applyshim)
+   *   (`shadycss/apply-shim.html`).
+   *
+   * To use:
+   *
+   * - Import `custom-style.html`.
+   * - Place a `<custom-style>` element in the main document, wrapping an inline `<style>` tag that
+   *   contains the CSS rules you want to shim.
+   *
+   * For example:
+   *
+   * ```
+   * <!-- import apply shim--only required if using mixins -->
+   * <link rel="import href="bower_components/shadycss/apply-shim.html">
+   * <!-- import custom-style element -->
+   * <link rel="import" href="bower_components/polymer/lib/elements/custom-style.html">
+   * ...
+   * <custom-style>
+   *   <style>
+   *     html {
+   *       --custom-color: blue;
+   *       --custom-mixin: {
+   *         font-weight: bold;
+   *         color: red;
+   *       };
+   *     }
+   *   </style>
+   * </custom-style>
+   * ```
+   */
+  class CustomStyle extends HTMLElement {
+
+    /**
+     * Returns the light-DOM `<style>` child this element wraps.  Upon first
+     * call any style modules referenced via the `include` attribute will be
+     * concatenated to this element's `<style>`.
+     *
+     * @returns This element's light-DOM `<style>`
+     */
+    getStyle(): HTMLStyleElement|null;
+  }
+}
+
+interface HTMLElementTagNameMap {
+  "custom-style": Polymer.CustomStyle;
+}
diff --git a/lib/elements/dom-bind.d.ts b/lib/elements/dom-bind.d.ts
new file mode 100644
index 0000000000..7f6af8495b
--- /dev/null
+++ b/lib/elements/dom-bind.d.ts
@@ -0,0 +1,53 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/elements/dom-bind.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../mixins/property-effects.d.ts" />
+/// <reference path="../mixins/mutable-data.d.ts" />
+/// <reference path="../mixins/gesture-event-listeners.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Custom element to allow using Polymer's template features (data binding,
+   * declarative event listeners, etc.) in the main document without defining
+   * a new custom element.
+   *
+   * `<template>` tags utilizing bindings may be wrapped with the `<dom-bind>`
+   * element, which will immediately stamp the wrapped template into the main
+   * document and bind elements to the `dom-bind` element itself as the
+   * binding scope.
+   */
+  class DomBind extends
+    Polymer.PropertyEffects(
+    Polymer.OptionalMutableData(
+    Polymer.GestureEventListeners(
+    Polymer.Element))) {
+
+    /**
+     * assumes only one observed attribute
+     */
+    attributeChangedCallback(): any;
+    connectedCallback(): any;
+    disconnectedCallback(): any;
+    __insertChildren(): any;
+    __removeChildren(): any;
+
+    /**
+     * Forces the element to render its content. This is typically only
+     * necessary to call if HTMLImports with the async attribute are used.
+     */
+    render(): any;
+  }
+}
+
+interface HTMLElementTagNameMap {
+  "dom-bind": Polymer.DomBind;
+}
diff --git a/lib/elements/dom-if.d.ts b/lib/elements/dom-if.d.ts
new file mode 100644
index 0000000000..746732f884
--- /dev/null
+++ b/lib/elements/dom-if.d.ts
@@ -0,0 +1,70 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/elements/dom-if.html
+ */
+
+/// <reference path="../../polymer-element.d.ts" />
+/// <reference path="../utils/templatize.d.ts" />
+/// <reference path="../utils/debounce.d.ts" />
+/// <reference path="../utils/flush.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * The `<dom-if>` element will stamp a light-dom `<template>` child when
+   * the `if` property becomes truthy, and the template can use Polymer
+   * data-binding and declarative event features when used in the context of
+   * a Polymer element's template.
+   *
+   * When `if` becomes falsy, the stamped content is hidden but not
+   * removed from dom. When `if` subsequently becomes truthy again, the content
+   * is simply re-shown. This approach is used due to its favorable performance
+   * characteristics: the expense of creating template content is paid only
+   * once and lazily.
+   *
+   * Set the `restamp` property to true to force the stamped content to be
+   * created / destroyed when the `if` condition changes.
+   */
+  class DomIf extends Polymer.Element {
+
+    /**
+     * A boolean indicating whether this template should stamp.
+     */
+    if: boolean;
+
+    /**
+     * When true, elements will be removed from DOM and discarded when `if`
+     * becomes false and re-created and added back to the DOM when `if`
+     * becomes true.  By default, stamped elements will be hidden but left
+     * in the DOM when `if` becomes false, which is generally results
+     * in better performance.
+     */
+    restamp: boolean;
+    connectedCallback(): any;
+    disconnectedCallback(): any;
+    __debounceRender(): any;
+
+    /**
+     * Forces the element to render its content. Normally rendering is
+     * asynchronous to a provoking change. This is done for efficiency so
+     * that multiple changes trigger only a single render. The render method
+     * should be called if, for example, template rendering is required to
+     * validate application state.
+     */
+    render(): any;
+    __render(): any;
+    __ensureInstance(): any;
+    __syncHostProperties(): any;
+    __teardownInstance(): any;
+    _showHideChildren(): any;
+  }
+}
+
+interface HTMLElementTagNameMap {
+  "dom-if": Polymer.DomIf;
+}
diff --git a/lib/elements/dom-module.d.ts b/lib/elements/dom-module.d.ts
new file mode 100644
index 0000000000..5cff353031
--- /dev/null
+++ b/lib/elements/dom-module.d.ts
@@ -0,0 +1,51 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/elements/dom-module.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/resolve-url.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * The `dom-module` element registers the dom it contains to the name given
+   * by the module's id attribute. It provides a unified database of dom
+   * accessible via its static `import` API.
+   *
+   * A key use case of `dom-module` is for providing custom element `<template>`s
+   * via HTML imports that are parsed by the native HTML parser, that can be
+   * relocated during a bundling pass and still looked up by `id`.
+   *
+   * Example:
+   *
+   *     <dom-module id="foo">
+   *       <img src="stuff.png">
+   *     </dom-module>
+   *
+   * Then in code in some other location that cannot access the dom-module above
+   *
+   *     let img = customElements.get('dom-module').import('foo', 'img');
+   */
+  class DomModule extends HTMLElement {
+    attributeChangedCallback(name: any, old: any, value: any): any;
+
+    /**
+     * Registers the dom-module at a given id. This method should only be called
+     * when a dom-module is imperatively created. For
+     * example, `document.createElement('dom-module').register('foo')`.
+     *
+     * @param id The id at which to register the dom-module.
+     */
+    register(id?: string): any;
+  }
+}
+
+interface HTMLElementTagNameMap {
+  "dom-module": Polymer.DomModule;
+}
diff --git a/lib/elements/dom-repeat.d.ts b/lib/elements/dom-repeat.d.ts
new file mode 100644
index 0000000000..7509563d77
--- /dev/null
+++ b/lib/elements/dom-repeat.d.ts
@@ -0,0 +1,298 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/elements/dom-repeat.html
+ */
+
+/// <reference path="../../polymer-element.d.ts" />
+/// <reference path="../utils/templatize.d.ts" />
+/// <reference path="../utils/debounce.d.ts" />
+/// <reference path="../utils/flush.d.ts" />
+/// <reference path="../mixins/mutable-data.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * The `<dom-repeat>` element will automatically stamp and binds one instance
+   * of template content to each object in a user-provided array.
+   * `dom-repeat` accepts an `items` property, and one instance of the template
+   * is stamped for each item into the DOM at the location of the `dom-repeat`
+   * element.  The `item` property will be set on each instance's binding
+   * scope, thus templates should bind to sub-properties of `item`.
+   *
+   * Example:
+   *
+   * ```html
+   * <dom-module id="employee-list">
+   *
+   *   <template>
+   *
+   *     <div> Employee list: </div>
+   *     <template is="dom-repeat" items="{{employees}}">
+   *         <div>First name: <span>{{item.first}}</span></div>
+   *         <div>Last name: <span>{{item.last}}</span></div>
+   *     </template>
+   *
+   *   </template>
+   *
+   *   <script>
+   *     Polymer({
+   *       is: 'employee-list',
+   *       ready: function() {
+   *         this.employees = [
+   *             {first: 'Bob', last: 'Smith'},
+   *             {first: 'Sally', last: 'Johnson'},
+   *             ...
+   *         ];
+   *       }
+   *     });
+   *   < /script>
+   *
+   * </dom-module>
+   * ```
+   *
+   * Notifications for changes to items sub-properties will be forwarded to template
+   * instances, which will update via the normal structured data notification system.
+   *
+   * Mutations to the `items` array itself should be made using the Array
+   * mutation API's on `Polymer.Base` (`push`, `pop`, `splice`, `shift`,
+   * `unshift`), and template instances will be kept in sync with the data in the
+   * array.
+   *
+   * Events caught by event handlers within the `dom-repeat` template will be
+   * decorated with a `model` property, which represents the binding scope for
+   * each template instance.  The model is an instance of Polymer.Base, and should
+   * be used to manipulate data on the instance, for example
+   * `event.model.set('item.checked', true);`.
+   *
+   * Alternatively, the model for a template instance for an element stamped by
+   * a `dom-repeat` can be obtained using the `modelForElement` API on the
+   * `dom-repeat` that stamped it, for example
+   * `this.$.domRepeat.modelForElement(event.target).set('item.checked', true);`.
+   * This may be useful for manipulating instance data of event targets obtained
+   * by event handlers on parents of the `dom-repeat` (event delegation).
+   *
+   * A view-specific filter/sort may be applied to each `dom-repeat` by supplying a
+   * `filter` and/or `sort` property.  This may be a string that names a function on
+   * the host, or a function may be assigned to the property directly.  The functions
+   * should implemented following the standard `Array` filter/sort API.
+   *
+   * In order to re-run the filter or sort functions based on changes to sub-fields
+   * of `items`, the `observe` property may be set as a space-separated list of
+   * `item` sub-fields that should cause a re-filter/sort when modified.  If
+   * the filter or sort function depends on properties not contained in `items`,
+   * the user should observe changes to those properties and call `render` to update
+   * the view based on the dependency change.
+   *
+   * For example, for an `dom-repeat` with a filter of the following:
+   *
+   * ```js
+   * isEngineer: function(item) {
+   *     return item.type == 'engineer' || item.manager.type == 'engineer';
+   * }
+   * ```
+   *
+   * Then the `observe` property should be configured as follows:
+   *
+   * ```html
+   * <template is="dom-repeat" items="{{employees}}"
+   *           filter="isEngineer" observe="type manager.type">
+   * ```
+   */
+  class DomRepeat extends
+    Polymer.OptionalMutableData(
+    Polymer.Element) {
+
+    /**
+     * An array containing items determining how many instances of the template
+     * to stamp and that that each template instance should bind to.
+     */
+    items: any[]|null;
+
+    /**
+     * The name of the variable to add to the binding scope for the array
+     * element associated with a given template instance.
+     */
+    as: string;
+
+    /**
+     * The name of the variable to add to the binding scope with the index
+     * of the instance in the sorted and filtered list of rendered items.
+     * Note, for the index in the `this.items` array, use the value of the
+     * `itemsIndexAs` property.
+     */
+    indexAs: string;
+
+    /**
+     * The name of the variable to add to the binding scope with the index
+     * of the instance in the `this.items` array. Note, for the index of
+     * this instance in the sorted and filtered list of rendered items,
+     * use the value of the `indexAs` property.
+     */
+    itemsIndexAs: string;
+
+    /**
+     * A function that should determine the sort order of the items.  This
+     * property should either be provided as a string, indicating a method
+     * name on the element's host, or else be an actual function.  The
+     * function should match the sort function passed to `Array.sort`.
+     * Using a sort function has no effect on the underlying `items` array.
+     */
+    sort: Function|null;
+
+    /**
+     * A function that can be used to filter items out of the view.  This
+     * property should either be provided as a string, indicating a method
+     * name on the element's host, or else be an actual function.  The
+     * function should match the sort function passed to `Array.filter`.
+     * Using a filter function has no effect on the underlying `items` array.
+     */
+    filter: Function|null;
+
+    /**
+     * When using a `filter` or `sort` function, the `observe` property
+     * should be set to a space-separated list of the names of item
+     * sub-fields that should trigger a re-sort or re-filter when changed.
+     * These should generally be fields of `item` that the sort or filter
+     * function depends on.
+     */
+    observe: string;
+
+    /**
+     * When using a `filter` or `sort` function, the `delay` property
+     * determines a debounce time in ms after a change to observed item
+     * properties that must pass before the filter or sort is re-run.
+     * This is useful in rate-limiting shuffling of the view when
+     * item changes may be frequent.
+     */
+    delay: number;
+
+    /**
+     * Count of currently rendered items after `filter` (if any) has been applied.
+     * If "chunking mode" is enabled, `renderedItemCount` is updated each time a
+     * set of template instances is rendered.
+     */
+    renderedItemCount: number;
+
+    /**
+     * Defines an initial count of template instances to render after setting
+     * the `items` array, before the next paint, and puts the `dom-repeat`
+     * into "chunking mode".  The remaining items will be created and rendered
+     * incrementally at each animation frame therof until all instances have
+     * been rendered.
+     */
+    initialCount: number;
+
+    /**
+     * When `initialCount` is used, this property defines a frame rate (in
+     * fps) to target by throttling the number of instances rendered each
+     * frame to not exceed the budget for the target frame rate.  The
+     * framerate is effectively the number of `requestAnimationFrame`s that
+     * it tries to allow to actually fire in a given second. It does this
+     * by measuring the time between `rAF`s and continuously adjusting the
+     * number of items created each `rAF` to maintain the target framerate.
+     * Setting this to a higher number allows lower latency and higher
+     * throughput for event handlers and other tasks, but results in a
+     * longer time for the remaining items to complete rendering.
+     */
+    targetFramerate: number;
+    _targetFrameTime: number;
+    disconnectedCallback(): any;
+    connectedCallback(): any;
+    __ensureTemplatized(): any;
+    __getMethodHost(): any;
+    __sortChanged(sort: any): any;
+    __filterChanged(filter: any): any;
+    __computeFrameTime(rate: any): any;
+    __initializeChunking(): any;
+    __tryRenderChunk(): any;
+    __requestRenderChunk(): any;
+    __renderChunk(): any;
+    __observeChanged(): any;
+    __itemsChanged(change: any): any;
+    __handleObservedPaths(path: any): any;
+
+    /**
+     * @param fn Function to debounce.
+     * @param delay Delay in ms to debounce by.
+     */
+    __debounceRender(fn: () => any, delay?: number): any;
+
+    /**
+     * Forces the element to render its content. Normally rendering is
+     * asynchronous to a provoking change. This is done for efficiency so
+     * that multiple changes trigger only a single render. The render method
+     * should be called if, for example, template rendering is required to
+     * validate application state.
+     */
+    render(): any;
+    __render(): any;
+    __applyFullRefresh(): any;
+    __detachInstance(idx: any): any;
+    __attachInstance(idx: any, parent: any): any;
+    __detachAndRemoveInstance(idx: any): any;
+    __stampInstance(item: any, instIdx: any, itemIdx: any): any;
+    __insertInstance(item: any, instIdx: any, itemIdx: any): any;
+
+    /**
+     * Implements extension point from Templatize mixin
+     */
+    _showHideChildren(hidden: any): any;
+
+    /**
+     * responsible for notifying item.<path> changes to inst for key
+     */
+    __handleItemPath(path: any, value: any): any;
+
+    /**
+     * Returns the item associated with a given element stamped by
+     * this `dom-repeat`.
+     *
+     * Note, to modify sub-properties of the item,
+     * `modelForElement(el).set('item.<sub-prop>', value)`
+     * should be used.
+     *
+     * @param el Element for which to return the item.
+     * @returns Item associated with the element.
+     */
+    itemForElement(el: HTMLElement|null): any;
+
+    /**
+     * Returns the inst index for a given element stamped by this `dom-repeat`.
+     * If `sort` is provided, the index will reflect the sorted order (rather
+     * than the original array order).
+     *
+     * @param el Element for which to return the index.
+     * @returns Row index associated with the element (note this may
+     *   not correspond to the array index if a user `sort` is applied).
+     */
+    indexForElement(el: HTMLElement|null): any;
+
+    /**
+     * Returns the template "model" associated with a given element, which
+     * serves as the binding scope for the template instance the element is
+     * contained in. A template model is an instance of `Polymer.Base`, and
+     * should be used to manipulate data associated with this template instance.
+     *
+     * Example:
+     *
+     *   let model = modelForElement(el);
+     *   if (model.index < 10) {
+     *     model.set('item.checked', true);
+     *   }
+     *
+     * @param el Element for which to return a template model.
+     * @returns Model representing the binding scope for
+     *   the element.
+     */
+    modelForElement(el: HTMLElement|null): TemplateInstanceBase|null;
+  }
+}
+
+interface HTMLElementTagNameMap {
+  "dom-repeat": Polymer.DomRepeat;
+}
diff --git a/lib/legacy/class.d.ts b/lib/legacy/class.d.ts
new file mode 100644
index 0000000000..7ef5cddc9e
--- /dev/null
+++ b/lib/legacy/class.d.ts
@@ -0,0 +1,105 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/legacy/class.html
+ */
+
+/// <reference path="legacy-element-mixin.d.ts" />
+
+declare namespace Polymer {
+
+
+  /**
+   * Applies a "legacy" behavior or array of behaviors to the provided class.
+   *
+   * Note: this method will automatically also apply the `Polymer.LegacyElementMixin`
+   * to ensure that any legacy behaviors can rely on legacy Polymer API on
+   * the underlying element.
+   */
+  function mixinBehaviors(behaviors: Object|any[]|null, klass: HTMLElement|(() => any)): () => any;
+
+
+  /**
+   * Generates a class that extends `Polymer.LegacyElement` based on the
+   * provided info object.  Metadata objects on the `info` object
+   * (`properties`, `observers`, `listeners`, `behaviors`, `is`) are used
+   * for Polymer's meta-programming systems, and any functions are copied
+   * to the generated class.
+   *
+   * Valid "metadata" values are as follows:
+   *
+   * `is`: String providing the tag name to register the element under. In
+   * addition, if a `dom-module` with the same id exists, the first template
+   * in that `dom-module` will be stamped into the shadow root of this element,
+   * with support for declarative event listeners (`on-...`), Polymer data
+   * bindings (`[[...]]` and `{{...}}`), and id-based node finding into
+   * `this.$`.
+   *
+   * `properties`: Object describing property-related metadata used by Polymer
+   * features (key: property names, value: object containing property metadata).
+   * Valid keys in per-property metadata include:
+   * - `type` (String|Number|Object|Array|...): Used by
+   *   `attributeChangedCallback` to determine how string-based attributes
+   *   are deserialized to JavaScript property values.
+   * - `notify` (boolean): Causes a change in the property to fire a
+   *   non-bubbling event called `<property>-changed`. Elements that have
+   *   enabled two-way binding to the property use this event to observe changes.
+   * - `readOnly` (boolean): Creates a getter for the property, but no setter.
+   *   To set a read-only property, use the private setter method
+   *   `_setProperty(property, value)`.
+   * - `observer` (string): Observer method name that will be called when
+   *   the property changes. The arguments of the method are
+   *   `(value, previousValue)`.
+   * - `computed` (string): String describing method and dependent properties
+   *   for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
+   *   Computed properties are read-only by default and can only be changed
+   *   via the return value of the computing method.
+   *
+   * `observers`: Array of strings describing multi-property observer methods
+   *  and their dependent properties (e.g. `'observeABC(a, b, c)'`).
+   *
+   * `listeners`: Object describing event listeners to be added to each
+   *  instance of this element (key: event name, value: method name).
+   *
+   * `behaviors`: Array of additional `info` objects containing metadata
+   * and callbacks in the same format as the `info` object here which are
+   * merged into this element.
+   *
+   * `hostAttributes`: Object listing attributes to be applied to the host
+   *  once created (key: attribute name, value: attribute value).  Values
+   *  are serialized based on the type of the value.  Host attributes should
+   *  generally be limited to attributes such as `tabIndex` and `aria-...`.
+   *  Attributes in `hostAttributes` are only applied if a user-supplied
+   *  attribute is not already present (attributes in markup override
+   *  `hostAttributes`).
+   *
+   * In addition, the following Polymer-specific callbacks may be provided:
+   * - `registered`: called after first instance of this element,
+   * - `created`: called during `constructor`
+   * - `attached`: called during `connectedCallback`
+   * - `detached`: called during `disconnectedCallback`
+   * - `ready`: called before first `attached`, after all properties of
+   *   this element have been propagated to its template and all observers
+   *   have run
+   */
+  function Class(info: PolymerInit): () => any;
+}
+
+declare class PolymerGenerated {
+  created(): any;
+  _registered(): any;
+  _applyListeners(): any;
+
+  /**
+   * only apply if not already set.
+   */
+  _ensureAttributes(): any;
+  ready(): any;
+  attached(): any;
+  detached(): any;
+  attributeChanged(name: any, old: any, value: any): any;
+}
diff --git a/lib/legacy/legacy-element-mixin.d.ts b/lib/legacy/legacy-element-mixin.d.ts
new file mode 100644
index 0000000000..149d7d6965
--- /dev/null
+++ b/lib/legacy/legacy-element-mixin.d.ts
@@ -0,0 +1,620 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/legacy/legacy-element-mixin.html
+ */
+
+/// <reference path="../../../shadycss/apply-shim.d.ts" />
+/// <reference path="../mixins/element-mixin.d.ts" />
+/// <reference path="../mixins/gesture-event-listeners.d.ts" />
+/// <reference path="../mixins/dir-mixin.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="../utils/import-href.d.ts" />
+/// <reference path="../utils/render-status.d.ts" />
+/// <reference path="../utils/unresolved.d.ts" />
+/// <reference path="polymer.dom.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element class mixin that provides Polymer's "legacy" API intended to be
+   * backward-compatible to the greatest extent possible with the API
+   * found on the Polymer 1.x `Polymer.Base` prototype applied to all elements
+   * defined using the `Polymer({...})` function.
+   */
+  function LegacyElementMixin<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+      isAttached: boolean;
+      __boundListeners: any;
+      _debouncers: any;
+
+      /**
+       * Provides an override implementation of `attributeChangedCallback`
+       * which adds the Polymer legacy API's `attributeChanged` method.
+       *
+       * @param name Name of attribute.
+       * @param old Old value of attribute.
+       * @param value Current value of attribute.
+       */
+      attributeChangedCallback(name: string, old: string|null, value: string|null): any;
+
+      /**
+       * Overrides the default `Polymer.PropertyEffects` implementation to
+       * add support for class initialization via the `_registered` callback.
+       * This is called only when the first instance of the element is created.
+       */
+      _initializeProperties(): any;
+
+      /**
+       * Overrides the default `Polymer.PropertyEffects` implementation to
+       * add support for installing `hostAttributes` and `listeners`.
+       */
+      ready(): any;
+
+      /**
+       * Provides an implementation of `connectedCallback`
+       * which adds Polymer legacy API's `attached` method.
+       */
+      connectedCallback(): any;
+
+      /**
+       * Provides an implementation of `disconnectedCallback`
+       * which adds Polymer legacy API's `detached` method.
+       */
+      disconnectedCallback(): any;
+
+      /**
+       * Legacy callback called during the `constructor`, for overriding
+       * by the user.
+       */
+      created(): any;
+
+      /**
+       * Legacy callback called during `connectedCallback`, for overriding
+       * by the user.
+       */
+      attached(): any;
+
+      /**
+       * Legacy callback called during `disconnectedCallback`, for overriding
+       * by the user.
+       */
+      detached(): any;
+
+      /**
+       * Legacy callback called during `attributeChangedChallback`, for overriding
+       * by the user.
+       *
+       * @param name Name of attribute.
+       * @param old Old value of attribute.
+       * @param value Current value of attribute.
+       */
+      attributeChanged(name: string, old: string|null, value: string|null): any;
+
+      /**
+       * Called automatically when an element is initializing.
+       * Users may override this method to perform class registration time
+       * work. The implementation should ensure the work is performed
+       * only once for the class.
+       */
+      _registered(): any;
+
+      /**
+       * Ensures an element has required attributes. Called when the element
+       * is being readied via `ready`. Users should override to set the
+       * element's required attributes. The implementation should be sure
+       * to check and not override existing attributes added by
+       * the user of the element. Typically, setting attributes should be left
+       * to the element user and not done here; reasonable exceptions include
+       * setting aria roles and focusability.
+       */
+      _ensureAttributes(): any;
+
+      /**
+       * Adds element event listeners. Called when the element
+       * is being readied via `ready`. Users should override to
+       * add any required element event listeners.
+       * In performance critical elements, the work done here should be kept
+       * to a minimum since it is done before the element is rendered. In
+       * these elements, consider adding listeners asynchronously so as not to
+       * block render.
+       */
+      _applyListeners(): any;
+
+      /**
+       * Converts a typed JavaScript value to a string.
+       *
+       * Note this method is provided as backward-compatible legacy API
+       * only.  It is not directly called by any Polymer features. To customize
+       * how properties are serialized to attributes for attribute bindings and
+       * `reflectToAttribute: true` properties as well as this method, override
+       * the `_serializeValue` method provided by `Polymer.PropertyAccessors`.
+       *
+       * @param value Value to deserialize
+       * @returns Serialized value
+       */
+      serialize(value: any): string|undefined;
+
+      /**
+       * Converts a string to a typed JavaScript value.
+       *
+       * Note this method is provided as backward-compatible legacy API
+       * only.  It is not directly called by any Polymer features.  To customize
+       * how attributes are deserialized to properties for in
+       * `attributeChangedCallback`, override `_deserializeValue` method
+       * provided by `Polymer.PropertyAccessors`.
+       *
+       * @param value String to deserialize
+       * @param type Type to deserialize the string to
+       * @returns Returns the deserialized value in the `type` given.
+       */
+      deserialize(value: string, type: any): any;
+
+      /**
+       * Serializes a property to its associated attribute.
+       *
+       * Note this method is provided as backward-compatible legacy API
+       * only.  It is not directly called by any Polymer features.
+       *
+       * @param property Property name to reflect.
+       * @param attribute Attribute name to reflect.
+       * @param value Property value to reflect.
+       */
+      reflectPropertyToAttribute(property: string, attribute?: string, value?: any): any;
+
+      /**
+       * Sets a typed value to an HTML attribute on a node.
+       *
+       * Note this method is provided as backward-compatible legacy API
+       * only.  It is not directly called by any Polymer features.
+       *
+       * @param value Value to serialize.
+       * @param attribute Attribute name to serialize to.
+       * @param node Element to set attribute to.
+       */
+      serializeValueToAttribute(value: any, attribute: string, node: Element|null): any;
+
+      /**
+       * Copies own properties (including accessor descriptors) from a source
+       * object to a target object.
+       *
+       * @param prototype Target object to copy properties to.
+       * @param api Source object to copy properties from.
+       * @returns prototype object that was passed as first argument.
+       */
+      extend(prototype: Object|null, api: Object|null): Object|null;
+
+      /**
+       * Copies props from a source object to a target object.
+       *
+       * Note, this method uses a simple `for...in` strategy for enumerating
+       * properties.  To ensure only `ownProperties` are copied from source
+       * to target and that accessor implementations are copied, use `extend`.
+       *
+       * @param target Target object to copy properties to.
+       * @param source Source object to copy properties from.
+       * @returns Target object that was passed as first argument.
+       */
+      mixin(target: Object|null, source: Object|null): Object|null;
+
+      /**
+       * Sets the prototype of an object.
+       *
+       * Note this method is provided as backward-compatible legacy API
+       * only.  It is not directly called by any Polymer features.
+       *
+       * @param object The object on which to set the prototype.
+       * @param prototype The prototype that will be set on the given
+       * `object`.
+       * @returns Returns the given `object` with its prototype set
+       * to the given `prototype` object.
+       */
+      chainObject(object: Object|null, prototype: Object|null): Object|null;
+
+      /**
+       * Calls `importNode` on the `content` of the `template` specified and
+       * returns a document fragment containing the imported content.
+       *
+       * @param template HTML template element to instance.
+       * @returns Document fragment containing the imported
+       *   template content.
+       */
+      instanceTemplate(template: HTMLTemplateElement|null): DocumentFragment|null;
+
+      /**
+       * Dispatches a custom event with an optional detail value.
+       *
+       * @param type Name of event type.
+       * @param detail Detail value containing event-specific
+       *   payload.
+       * @param options Object specifying options.  These may include:
+       *  `bubbles` (boolean, defaults to `true`),
+       *  `cancelable` (boolean, defaults to false), and
+       *  `node` on which to fire the event (HTMLElement, defaults to `this`).
+       * @returns The new event that was fired.
+       */
+      fire(type: string, detail?: any, options?: any): Event|null;
+
+      /**
+       * Convenience method to add an event listener on a given element,
+       * late bound to a named method on this element.
+       *
+       * @param node Element to add event listener to.
+       * @param eventName Name of event to listen for.
+       * @param methodName Name of handler method on `this` to call.
+       */
+      listen(node: Element|null, eventName: string, methodName: string): any;
+
+      /**
+       * Convenience method to remove an event listener from a given element,
+       * late bound to a named method on this element.
+       *
+       * @param node Element to remove event listener from.
+       * @param eventName Name of event to stop listening to.
+       * @param methodName Name of handler method on `this` to not call
+       *        anymore.
+       */
+      unlisten(node: Element|null, eventName: string, methodName: string): any;
+
+      /**
+       * Override scrolling behavior to all direction, one direction, or none.
+       *
+       * Valid scroll directions:
+       *   - 'all': scroll in any direction
+       *   - 'x': scroll only in the 'x' direction
+       *   - 'y': scroll only in the 'y' direction
+       *   - 'none': disable scrolling for this node
+       *
+       * @param direction Direction to allow scrolling
+       * Defaults to `all`.
+       * @param node Element to apply scroll direction setting.
+       * Defaults to `this`.
+       */
+      setScrollDirection(direction?: string, node?: Element|null): any;
+
+      /**
+       * Convenience method to run `querySelector` on this local DOM scope.
+       *
+       * This function calls `Polymer.dom(this.root).querySelector(slctr)`.
+       *
+       * @param slctr Selector to run on this local DOM scope
+       * @returns Element found by the selector, or null if not found.
+       */
+      $$(slctr: string): Element|null;
+
+      /**
+       * Force this element to distribute its children to its local dom.
+       * This should not be necessary as of Polymer 2.0.2 and is provided only
+       * for backwards compatibility.
+       */
+      distributeContent(): any;
+
+      /**
+       * Returns a list of nodes that are the effective childNodes. The effective
+       * childNodes list is the same as the element's childNodes except that
+       * any `<content>` elements are replaced with the list of nodes distributed
+       * to the `<content>`, the result of its `getDistributedNodes` method.
+       *
+       * @returns List of effective child nodes.
+       */
+      getEffectiveChildNodes(): Array<Node|null>|null;
+
+      /**
+       * Returns a list of nodes distributed within this element that match
+       * `selector`. These can be dom children or elements distributed to
+       * children that are insertion points.
+       *
+       * @param selector Selector to run.
+       * @returns List of distributed elements that match selector.
+       */
+      queryDistributedElements(selector: string): Array<Node|null>|null;
+
+      /**
+       * Returns a list of elements that are the effective children. The effective
+       * children list is the same as the element's children except that
+       * any `<content>` elements are replaced with the list of elements
+       * distributed to the `<content>`.
+       *
+       * @returns List of effective children.
+       */
+      getEffectiveChildren(): Array<Node|null>|null;
+
+      /**
+       * Returns a string of text content that is the concatenation of the
+       * text content's of the element's effective childNodes (the elements
+       * returned by <a href="#getEffectiveChildNodes>getEffectiveChildNodes</a>.
+       *
+       * @returns List of effective children.
+       */
+      getEffectiveTextContent(): string;
+
+      /**
+       * Returns the first effective childNode within this element that
+       * match `selector`. These can be dom child nodes or elements distributed
+       * to children that are insertion points.
+       *
+       * @param selector Selector to run.
+       * @returns First effective child node that matches selector.
+       */
+      queryEffectiveChildren(selector: string): any;
+
+      /**
+       * Returns a list of effective childNodes within this element that
+       * match `selector`. These can be dom child nodes or elements distributed
+       * to children that are insertion points.
+       *
+       * @param selector Selector to run.
+       * @returns List of effective child nodes that match selector.
+       */
+      queryAllEffectiveChildren(selector: string): Array<Node|null>|null;
+
+      /**
+       * Returns a list of nodes distributed to this element's `<slot>`.
+       *
+       * If this element contains more than one `<slot>` in its local DOM,
+       * an optional selector may be passed to choose the desired content.
+       *
+       * @param slctr CSS selector to choose the desired
+       *   `<slot>`.  Defaults to `content`.
+       * @returns List of distributed nodes for the `<slot>`.
+       */
+      getContentChildNodes(slctr?: string): Array<Node|null>|null;
+
+      /**
+       * Returns a list of element children distributed to this element's
+       * `<slot>`.
+       *
+       * If this element contains more than one `<slot>` in its
+       * local DOM, an optional selector may be passed to choose the desired
+       * content.  This method differs from `getContentChildNodes` in that only
+       * elements are returned.
+       *
+       * @param slctr CSS selector to choose the desired
+       *   `<content>`.  Defaults to `content`.
+       * @returns List of distributed nodes for the
+       *   `<slot>`.
+       */
+      getContentChildren(slctr?: string): Array<HTMLElement|null>|null;
+
+      /**
+       * Checks whether an element is in this element's light DOM tree.
+       *
+       * @param node The element to be checked.
+       * @returns true if node is in this element's light DOM tree.
+       */
+      isLightDescendant(node: Node|null): boolean;
+
+      /**
+       * Checks whether an element is in this element's local DOM tree.
+       *
+       * @param node The element to be checked.
+       * @returns true if node is in this element's local DOM tree.
+       */
+      isLocalDescendant(node?: Element|null): boolean;
+
+      /**
+       * NOTE: should now be handled by ShadyCss library.
+       */
+      scopeSubtree(container: any, shouldObserve: any): any;
+
+      /**
+       * Returns the computed style value for the given property.
+       *
+       * @param property The css property name.
+       * @returns Returns the computed css property value for the given
+       * `property`.
+       */
+      getComputedStyleValue(property: string): string;
+
+      /**
+       * Call `debounce` to collapse multiple requests for a named task into
+       * one invocation which is made after the wait time has elapsed with
+       * no new request.  If no wait time is given, the callback will be called
+       * at microtask timing (guaranteed before paint).
+       *
+       *     debouncedClickAction(e) {
+       *       // will not call `processClick` more than once per 100ms
+       *       this.debounce('click', function() {
+       *        this.processClick();
+       *       } 100);
+       *     }
+       *
+       * @param jobName String to identify the debounce job.
+       * @param callback Function that is called (with `this`
+       *   context) when the wait time elapses.
+       * @param wait Optional wait time in milliseconds (ms) after the
+       *   last signal that must elapse before invoking `callback`
+       * @returns Returns a debouncer object on which exists the
+       * following methods: `isActive()` returns true if the debouncer is
+       * active; `cancel()` cancels the debouncer if it is active;
+       * `flush()` immediately invokes the debounced callback if the debouncer
+       * is active.
+       */
+      debounce(jobName: string, callback: () => any, wait: number): Object|null;
+
+      /**
+       * Returns whether a named debouncer is active.
+       *
+       * @param jobName The name of the debouncer started with `debounce`
+       * @returns Whether the debouncer is active (has not yet fired).
+       */
+      isDebouncerActive(jobName: string): boolean;
+
+      /**
+       * Immediately calls the debouncer `callback` and inactivates it.
+       *
+       * @param jobName The name of the debouncer started with `debounce`
+       */
+      flushDebouncer(jobName: string): any;
+
+      /**
+       * Cancels an active debouncer.  The `callback` will not be called.
+       *
+       * @param jobName The name of the debouncer started with `debounce`
+       */
+      cancelDebouncer(jobName: string): any;
+
+      /**
+       * Runs a callback function asynchronously.
+       *
+       * By default (if no waitTime is specified), async callbacks are run at
+       * microtask timing, which will occur before paint.
+       *
+       * @param callback The callback function to run, bound to `this`.
+       * @param waitTime Time to wait before calling the
+       *   `callback`.  If unspecified or 0, the callback will be run at microtask
+       *   timing (before paint).
+       * @returns Handle that may be used to cancel the async job.
+       */
+      async(callback: Function|null, waitTime?: number): number;
+
+      /**
+       * Cancels an async operation started with `async`.
+       *
+       * @param handle Handle returned from original `async` call to
+       *   cancel.
+       */
+      cancelAsync(handle: number): any;
+
+      /**
+       * Convenience method for creating an element and configuring it.
+       *
+       * @param tag HTML element tag to create.
+       * @param props Object of properties to configure on the
+       *    instance.
+       * @returns Newly created and configured element.
+       */
+      create(tag: string, props: Object|null): Element|null;
+
+      /**
+       * Convenience method for importing an HTML document imperatively.
+       *
+       * This method creates a new `<link rel="import">` element with
+       * the provided URL and appends it to the document to start loading.
+       * In the `onload` callback, the `import` property of the `link`
+       * element will contain the imported document contents.
+       *
+       * @param href URL to document to load.
+       * @param onload Callback to notify when an import successfully
+       *   loaded.
+       * @param onerror Callback to notify when an import
+       *   unsuccessfully loaded.
+       * @param optAsync True if the import should be loaded `async`.
+       *   Defaults to `false`.
+       * @returns The link element for the URL to be loaded.
+       */
+      importHref(href: string, onload: Function|null, onerror: Function|null, optAsync: boolean): HTMLLinkElement|null;
+
+      /**
+       * Polyfill for Element.prototype.matches, which is sometimes still
+       * prefixed.
+       *
+       * @param selector Selector to test.
+       * @param node Element to test the selector against.
+       * @returns Whether the element matches the selector.
+       */
+      elementMatches(selector: string, node?: Element|null): boolean;
+
+      /**
+       * Toggles an HTML attribute on or off.
+       *
+       * @param name HTML attribute name
+       * @param bool Boolean to force the attribute on or off.
+       *    When unspecified, the state of the attribute will be reversed.
+       * @param node Node to target.  Defaults to `this`.
+       */
+      toggleAttribute(name: string, bool?: boolean, node?: Element|null): any;
+
+      /**
+       * Toggles a CSS class on or off.
+       *
+       * @param name CSS class name
+       * @param bool Boolean to force the class on or off.
+       *    When unspecified, the state of the class will be reversed.
+       * @param node Node to target.  Defaults to `this`.
+       */
+      toggleClass(name: string, bool?: boolean, node?: Element|null): any;
+
+      /**
+       * Cross-platform helper for setting an element's CSS `transform` property.
+       *
+       * @param transformText Transform setting.
+       * @param node Element to apply the transform to.
+       * Defaults to `this`
+       */
+      transform(transformText: string, node?: Element|null): any;
+
+      /**
+       * Cross-platform helper for setting an element's CSS `translate3d`
+       * property.
+       *
+       * @param x X offset.
+       * @param y Y offset.
+       * @param z Z offset.
+       * @param node Element to apply the transform to.
+       * Defaults to `this`.
+       */
+      translate3d(x: number, y: number, z: number, node?: Element|null): any;
+
+      /**
+       * Removes an item from an array, if it exists.
+       *
+       * If the array is specified by path, a change notification is
+       * generated, so that observers, data bindings and computed
+       * properties watching that path can update.
+       *
+       * If the array is passed directly, **no change
+       * notification is generated**.
+       *
+       * @param arrayOrPath Path to array from which to remove the item
+       *   (or the array itself).
+       * @param item Item to remove.
+       * @returns Array containing item removed.
+       */
+      arrayDelete(arrayOrPath: string|Array<number|string>, item: any): any[]|null;
+
+      /**
+       * Facades `console.log`/`warn`/`error` as override point.
+       *
+       * @param level One of 'log', 'warn', 'error'
+       * @param args Array of strings or objects to log
+       */
+      _logger(level: string, args: any[]|null): any;
+
+      /**
+       * Facades `console.log` as an override point.
+       *
+       * @param args Array of strings or objects to log
+       */
+      _log(...args: any[]): any;
+
+      /**
+       * Facades `console.warn` as an override point.
+       *
+       * @param args Array of strings or objects to log
+       */
+      _warn(...args: any[]): any;
+
+      /**
+       * Facades `console.error` as an override point.
+       *
+       * @param args Array of strings or objects to log
+       */
+      _error(...args: any[]): any;
+
+      /**
+       * Formats a message using the element type an a method name.
+       *
+       * @param methodName Method name to associate with message
+       * @param args Array of strings or objects to log
+       * @returns Array with formatting information for `console`
+       *   logging.
+       */
+      _logf(methodName: string, ...args: any[]): any[]|null;
+    }
+  } & T
+}
diff --git a/lib/legacy/mutable-data-behavior.d.ts b/lib/legacy/mutable-data-behavior.d.ts
new file mode 100644
index 0000000000..fad6fa58b4
--- /dev/null
+++ b/lib/legacy/mutable-data-behavior.d.ts
@@ -0,0 +1,131 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/legacy/mutable-data-behavior.html
+ */
+
+/// <reference path="../mixins/mutable-data.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Legacy element behavior to skip strict dirty-checking for objects and arrays,
+   * (always consider them to be "dirty") for use on legacy API Polymer elements.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will cause Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   * Specifically, any elements in the binding tree between the source of a
+   * mutation and the consumption of it must apply this behavior or enable the
+   * `Polymer.OptionalMutableDataBehavior`.
+   *
+   * In order to make the dirty check strategy configurable, see
+   * `Polymer.OptionalMutableDataBehavior`.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse as opposed to using strict dirty checking with immutable
+   * patterns or Polymer's path notification API.
+   */
+  interface MutableDataBehavior {
+
+    /**
+     * Overrides `Polymer.PropertyEffects` to provide option for skipping
+     * strict equality checking for Objects and Arrays.
+     *
+     * This method pulls the value to dirty check against from the `__dataTemp`
+     * cache (rather than the normal `__data` cache) for Objects.  Since the temp
+     * cache is cleared at the end of a turn, this implementation allows
+     * side-effects of deep object changes to be processed by re-setting the
+     * same object (using the temp cache as an in-turn backstop to prevent
+     * cycles due to 2-way notification).
+     *
+     * @param property Property name
+     * @param value New property value
+     * @param old Previous property value
+     * @returns Whether the property should be considered a change
+     */
+    _shouldPropertyChange(property: string, value: any, old: any): boolean;
+  }
+
+  /**
+   * Legacy element behavior to add the optional ability to skip strict
+   * dirty-checking for objects and arrays (always consider them to be
+   * "dirty") by setting a `mutable-data` attribute on an element instance.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will allow Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   * Specifically, any elements in the binding tree between the source of a
+   * mutation and the consumption of it must enable this behavior or apply the
+   * `Polymer.OptionalMutableDataBehavior`.
+   *
+   * While this behavior adds the ability to forgo Object/Array dirty checking,
+   * the `mutableData` flag defaults to false and must be set on the instance.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse by relying on `mutableData: true` as opposed to using
+   * strict dirty checking with immutable patterns or Polymer's path notification
+   * API.
+   */
+  interface OptionalMutableDataBehavior {
+
+    /**
+     * Instance-level flag for configuring the dirty-checking strategy
+     * for this element.  When true, Objects and Arrays will skip dirty
+     * checking, otherwise strict equality checking will be used.
+     */
+    mutableData: boolean;
+
+    /**
+     * Overrides `Polymer.PropertyEffects` to skip strict equality checking
+     * for Objects and Arrays.
+     *
+     * Pulls the value to dirty check against from the `__dataTemp` cache
+     * (rather than the normal `__data` cache) for Objects.  Since the temp
+     * cache is cleared at the end of a turn, this implementation allows
+     * side-effects of deep object changes to be processed by re-setting the
+     * same object (using the temp cache as an in-turn backstop to prevent
+     * cycles due to 2-way notification).
+     *
+     * @param property Property name
+     * @param value New property value
+     * @param old Previous property value
+     * @returns Whether the property should be considered a change
+     */
+    _shouldPropertyChange(property: string, value: any, old: any): boolean;
+  }
+}
diff --git a/lib/legacy/polymer-fn.d.ts b/lib/legacy/polymer-fn.d.ts
new file mode 100644
index 0000000000..34d12d466f
--- /dev/null
+++ b/lib/legacy/polymer-fn.d.ts
@@ -0,0 +1,12 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/legacy/polymer-fn.html
+ */
+
+/// <reference path="class.d.ts" />
+
diff --git a/lib/legacy/polymer.dom.d.ts b/lib/legacy/polymer.dom.d.ts
new file mode 100644
index 0000000000..8b27389b4e
--- /dev/null
+++ b/lib/legacy/polymer.dom.d.ts
@@ -0,0 +1,136 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/legacy/polymer.dom.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/settings.d.ts" />
+/// <reference path="../utils/flattened-nodes-observer.d.ts" />
+/// <reference path="../utils/flush.d.ts" />
+
+declare namespace Polymer {
+
+  namespace dom {
+
+
+    /**
+     * Cross-platform `element.matches` shim.
+     */
+    function matchesSelector(node: Element, selector: string): boolean;
+  }
+
+  /**
+   * Node API wrapper class returned from `Polymer.dom.(target)` when
+   * `target` is a `Node`.
+   */
+  class DomApi {
+
+    /**
+     * Returns an instance of `Polymer.FlattenedNodesObserver` that
+     * listens for node changes on this element.
+     *
+     * @param callback Called when direct or distributed children
+     *   of this element changes
+     * @returns Observer instance
+     */
+    observeNodes(callback: Function|null): Polymer.FlattenedNodesObserver|null;
+
+    /**
+     * Disconnects an observer previously created via `observeNodes`
+     *
+     * @param observerHandle Observer instance
+     *   to disconnect.
+     */
+    unobserveNodes(observerHandle: Polymer.FlattenedNodesObserver|null): any;
+
+    /**
+     * Provided as a backwards-compatible API only.  This method does nothing.
+     */
+    notifyObserver(): any;
+
+    /**
+     * Returns true if the provided node is contained with this element's
+     * light-DOM children or shadow root, including any nested shadow roots
+     * of children therein.
+     *
+     * @param node Node to test
+     * @returns Returns true if the given `node` is contained within
+     *   this element's light or shadow DOM.
+     */
+    deepContains(node: Node|null): boolean;
+
+    /**
+     * Returns the root node of this node.  Equivalent to `getRoodNode()`.
+     *
+     * @returns Top most element in the dom tree in which the node
+     * exists. If the node is connected to a document this is either a
+     * shadowRoot or the document; otherwise, it may be the node
+     * itself or a node or document fragment containing it.
+     */
+    getOwnerRoot(): Node|null;
+
+    /**
+     * For slot elements, returns the nodes assigned to the slot; otherwise
+     * an empty array. It is equivalent to `<slot>.addignedNodes({flatten:true})`.
+     *
+     * @returns Array of assigned nodes
+     */
+    getDistributedNodes(): Array<Node|null>|null;
+
+    /**
+     * Returns an array of all slots this element was distributed to.
+     *
+     * @returns Description
+     */
+    getDestinationInsertionPoints(): Array<HTMLSlotElement|null>|null;
+
+    /**
+     * Calls `importNode` on the `ownerDocument` for this node.
+     *
+     * @param node Node to import
+     * @param deep True if the node should be cloned deeply during
+     *   import
+     * @returns Clone of given node imported to this owner document
+     */
+    importNode(node: Node|null, deep: boolean): Node|null;
+
+    /**
+     * @returns Returns a flattened list of all child nodes and nodes assigned
+     * to child slots.
+     */
+    getEffectiveChildNodes(): any[]|null;
+
+    /**
+     * Returns a filtered list of flattened child elements for this element based
+     * on the given selector.
+     *
+     * @param selector Selector to filter nodes against
+     * @returns List of flattened child elements
+     */
+    queryDistributedElements(selector: string): Array<HTMLElement|null>|null;
+  }
+
+
+  /**
+   * Legacy DOM and Event manipulation API wrapper factory used to abstract
+   * differences between native Shadow DOM and "Shady DOM" when polyfilling on
+   * older browsers.
+   *
+   * Note that in Polymer 2.x use of `Polymer.dom` is no longer required and
+   * in the majority of cases simply facades directly to the standard native
+   * API.
+   */
+  function dom(obj: Node|Event|null): DomApi|EventApi|null;
+}
+
+/**
+ * Event API wrapper class returned from `Polymer.dom.(target)` when
+ * `target` is an `Event`.
+ */
+declare class EventApi {
+}
diff --git a/lib/legacy/templatizer-behavior.d.ts b/lib/legacy/templatizer-behavior.d.ts
new file mode 100644
index 0000000000..d4eea609fc
--- /dev/null
+++ b/lib/legacy/templatizer-behavior.d.ts
@@ -0,0 +1,114 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/legacy/templatizer-behavior.html
+ */
+
+/// <reference path="../utils/templatize.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * The `Polymer.Templatizer` behavior adds methods to generate instances of
+   * templates that are each managed by an anonymous `Polymer.PropertyEffects`
+   * instance where data-bindings in the stamped template content are bound to
+   * accessors on itself.
+   *
+   * This behavior is provided in Polymer 2.x as a hybrid-element convenience
+   * only.  For non-hybrid usage, the `Polymer.Templatize` library
+   * should be used instead.
+   *
+   * Example:
+   *
+   *     // Get a template from somewhere, e.g. light DOM
+   *     let template = this.querySelector('template');
+   *     // Prepare the template
+   *     this.templatize(template);
+   *     // Instance the template with an initial data model
+   *     let instance = this.stamp({myProp: 'initial'});
+   *     // Insert the instance's DOM somewhere, e.g. light DOM
+   *     Polymer.dom(this).appendChild(instance.root);
+   *     // Changing a property on the instance will propagate to bindings
+   *     // in the template
+   *     instance.myProp = 'new value';
+   *
+   * Users of `Templatizer` may need to implement the following abstract
+   * API's to determine how properties and paths from the host should be
+   * forwarded into to instances:
+   *
+   *     _forwardHostPropV2: function(prop, value)
+   *
+   * Likewise, users may implement these additional abstract API's to determine
+   * how instance-specific properties that change on the instance should be
+   * forwarded out to the host, if necessary.
+   *
+   *     _notifyInstancePropV2: function(inst, prop, value)
+   *
+   * In order to determine which properties are instance-specific and require
+   * custom notification via `_notifyInstanceProp`, define an `_instanceProps`
+   * object containing keys for each instance prop, for example:
+   *
+   *     _instanceProps: {
+   *       item: true,
+   *       index: true
+   *     }
+   *
+   * Any properties used in the template that are not defined in _instanceProp
+   * will be forwarded out to the Templatize `owner` automatically.
+   *
+   * Users may also implement the following abstract function to show or
+   * hide any DOM generated using `stamp`:
+   *
+   *     _showHideChildren: function(shouldHide)
+   *
+   * Note that some callbacks are suffixed with `V2` in the Polymer 2.x behavior
+   * as the implementations will need to differ from the callbacks required
+   * by the 1.x Templatizer API due to changes in the `TemplateInstance` API
+   * between versions 1.x and 2.x.
+   */
+  interface Templatizer {
+
+    /**
+     * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
+     * for the provided template.  This method should be called once per
+     * template to prepare an element for stamping the template, followed
+     * by `stamp` to create new instances of the template.
+     *
+     * @param template Template to prepare
+     * @param mutableData When `true`, the generated class will skip
+     *   strict dirty-checking for objects and arrays (always consider them to
+     *   be "dirty"). Defaults to false.
+     */
+    templatize(template: HTMLTemplateElement|null, mutableData?: boolean): any;
+
+    /**
+     * Creates an instance of the template prepared by `templatize`.  The object
+     * returned is an instance of the anonymous class generated by `templatize`
+     * whose `root` property is a document fragment containing newly cloned
+     * template content, and which has property accessors corresponding to
+     * properties referenced in template bindings.
+     *
+     * @param model Object containing initial property values to
+     *   populate into the template bindings.
+     * @returns Returns the created instance of
+     * the template prepared by `templatize`.
+     */
+    stamp(model?: Object|null): TemplateInstanceBase|null;
+
+    /**
+     * Returns the template "model" (`TemplateInstance`) associated with
+     * a given element, which serves as the binding scope for the template
+     * instance the element is contained in.  A template model should be used
+     * to manipulate data associated with this template instance.
+     *
+     * @param el Element for which to return a template model.
+     * @returns Model representing the binding scope for
+     *   the element.
+     */
+    modelForElement(el: HTMLElement|null): TemplateInstanceBase|null;
+  }
+}
diff --git a/lib/mixins/dir-mixin.d.ts b/lib/mixins/dir-mixin.d.ts
new file mode 100644
index 0000000000..4e952226ae
--- /dev/null
+++ b/lib/mixins/dir-mixin.d.ts
@@ -0,0 +1,39 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/dir-mixin.html
+ */
+
+/// <reference path="property-accessors.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element class mixin that allows elements to use the `:dir` CSS Selector to have
+   * text direction specific styling.
+   *
+   * With this mixin, any stylesheet provided in the template will transform `:dir` into
+   * `:host([dir])` and sync direction with the page via the element's `dir` attribute.
+   *
+   * Elements can opt out of the global page text direction by setting the `dir` attribute
+   * directly in `ready()` or in HTML.
+   *
+   * Caveats:
+   * - Applications must set `<html dir="ltr">` or `<html dir="rtl">` to sync direction
+   * - Automatic left-to-right or right-to-left styling is sync'd with the `<html>` element only.
+   * - Changing `dir` at runtime is supported.
+   * - Opting out of the global direction styling is permanent
+   */
+  function DirMixin<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+      __autoDirOptOut: boolean;
+      ready(): any;
+      connectedCallback(): any;
+      disconnectedCallback(): any;
+    }
+  } & T
+}
diff --git a/lib/mixins/element-mixin.d.ts b/lib/mixins/element-mixin.d.ts
new file mode 100644
index 0000000000..0488620982
--- /dev/null
+++ b/lib/mixins/element-mixin.d.ts
@@ -0,0 +1,185 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/element-mixin.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/settings.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="../utils/case-map.d.ts" />
+/// <reference path="../utils/style-gather.d.ts" />
+/// <reference path="../utils/resolve-url.d.ts" />
+/// <reference path="../elements/dom-module.d.ts" />
+/// <reference path="property-effects.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element class mixin that provides the core API for Polymer's meta-programming
+   * features including template stamping, data-binding, attribute deserialization,
+   * and property change observation.
+   *
+   * Subclassers may provide the following static getters to return metadata
+   * used to configure Polymer's features for the class:
+   *
+   * - `static get is()`: When the template is provided via a `dom-module`,
+   *   users should return the `dom-module` id from a static `is` getter.  If
+   *   no template is needed or the template is provided directly via the
+   *   `template` getter, there is no need to define `is` for the element.
+   *
+   * - `static get template()`: Users may provide the template directly (as
+   *   opposed to via `dom-module`) by implementing a static `template` getter.
+   *   The getter may return an `HTMLTemplateElement` or a string, which will
+   *   automatically be parsed into a template.
+   *
+   * - `static get properties()`: Should return an object describing
+   *   property-related metadata used by Polymer features (key: property name
+   *   value: object containing property metadata). Valid keys in per-property
+   *   metadata include:
+   *   - `type` (String|Number|Object|Array|...): Used by
+   *     `attributeChangedCallback` to determine how string-based attributes
+   *     are deserialized to JavaScript property values.
+   *   - `notify` (boolean): Causes a change in the property to fire a
+   *     non-bubbling event called `<property>-changed`. Elements that have
+   *     enabled two-way binding to the property use this event to observe changes.
+   *   - `readOnly` (boolean): Creates a getter for the property, but no setter.
+   *     To set a read-only property, use the private setter method
+   *     `_setProperty(property, value)`.
+   *   - `observer` (string): Observer method name that will be called when
+   *     the property changes. The arguments of the method are
+   *     `(value, previousValue)`.
+   *   - `computed` (string): String describing method and dependent properties
+   *     for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
+   *     Computed properties are read-only by default and can only be changed
+   *     via the return value of the computing method.
+   *
+   * - `static get observers()`: Array of strings describing multi-property
+   *   observer methods and their dependent properties (e.g.
+   *   `'observeABC(a, b, c)'`).
+   *
+   * The base class provides default implementations for the following standard
+   * custom element lifecycle callbacks; users may override these, but should
+   * call the super method to ensure
+   * - `constructor`: Run when the element is created or upgraded
+   * - `connectedCallback`: Run each time the element is connected to the
+   *   document
+   * - `disconnectedCallback`: Run each time the element is disconnected from
+   *   the document
+   * - `attributeChangedCallback`: Run each time an attribute in
+   *   `observedAttributes` is set or removed (note: this element's default
+   *   `observedAttributes` implementation will automatically return an array
+   *   of dash-cased attributes based on `properties`)
+   */
+  function ElementMixin<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+      _template: HTMLTemplateElement|null;
+      _importPath: string;
+      rootPath: string;
+      importPath: string;
+      root: StampedTemplate|HTMLElement|ShadowRoot|null;
+      $: any;
+
+      /**
+       * Provides a default implementation of the standard Custom Elements
+       * `attributeChangedCallback`.
+       *
+       * By default, attributes declared in `properties` metadata are
+       * deserialized using their `type` information to properties of the
+       * same name.  "Dash-cased" attributes are deserialized to "camelCase"
+       * properties.
+       *
+       * @param name Name of attribute.
+       * @param old Old value of attribute.
+       * @param value Current value of attribute.
+       */
+      attributeChangedCallback(name: string, old: string|null, value: string|null): any;
+
+      /**
+       * Overrides the default `Polymer.PropertyAccessors` to ensure class
+       * metaprogramming related to property accessors and effects has
+       * completed (calls `finalize`).
+       *
+       * It also initializes any property defaults provided via `value` in
+       * `properties` metadata.
+       */
+      _initializeProperties(): any;
+
+      /**
+       * Stamps the element template.
+       */
+      ready(): any;
+
+      /**
+       * Implements `PropertyEffects`'s `_readyClients` call. Attaches
+       * element dom by calling `_attachDom` with the dom stamped from the
+       * element's template via `_stampTemplate`. Note that this allows
+       * client dom to be attached to the element prior to any observers
+       * running.
+       */
+      _readyClients(): any;
+
+      /**
+       * Provides a default implementation of the standard Custom Elements
+       * `connectedCallback`.
+       *
+       * The default implementation enables the property effects system and
+       * flushes any pending properties, and updates shimmed CSS properties
+       * when using the ShadyCSS scoping/custom properties polyfill.
+       */
+      connectedCallback(): any;
+
+      /**
+       * Provides a default implementation of the standard Custom Elements
+       * `disconnectedCallback`.
+       */
+      disconnectedCallback(): any;
+
+      /**
+       * Attaches an element's stamped dom to itself. By default,
+       * this method creates a `shadowRoot` and adds the dom to it.
+       * However, this method may be overridden to allow an element
+       * to put its dom in another location.
+       *
+       * @param dom to attach to the element.
+       * @returns node to which the dom has been attached.
+       */
+      _attachDom(dom: StampedTemplate|null): ShadowRoot|null;
+
+      /**
+       * When using the ShadyCSS scoping and custom property shim, causes all
+       * shimmed styles in this element (and its subtree) to be updated
+       * based on current custom property values.
+       *
+       * The optional parameter overrides inline custom property styles with an
+       * object of properties where the keys are CSS properties, and the values
+       * are strings.
+       *
+       * Example: `this.updateStyles({'--color': 'blue'})`
+       *
+       * These properties are retained unless a value of `null` is set.
+       *
+       * @param properties Bag of custom property key/values to
+       *   apply to this element.
+       */
+      updateStyles(properties?: Object|null): any;
+
+      /**
+       * Rewrites a given URL relative to a base URL. The base URL defaults to
+       * the original location of the document containing the `dom-module` for
+       * this element. This method will return the same URL before and after
+       * bundling.
+       *
+       * @param url URL to resolve.
+       * @param base Optional base URL to resolve against, defaults
+       * to the element's `importPath`
+       * @returns Rewritten URL relative to base
+       */
+      resolveUrl(url: string, base?: string): string;
+    }
+  } & T
+}
diff --git a/lib/mixins/gesture-event-listeners.d.ts b/lib/mixins/gesture-event-listeners.d.ts
new file mode 100644
index 0000000000..d7d9732f97
--- /dev/null
+++ b/lib/mixins/gesture-event-listeners.d.ts
@@ -0,0 +1,32 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/gesture-event-listeners.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="../utils/gestures.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element class mixin that provides API for adding Polymer's cross-platform
+   * gesture events to nodes.
+   *
+   * The API is designed to be compatible with override points implemented
+   * in `Polymer.TemplateStamp` such that declarative event listeners in
+   * templates will support gesture events when this mixin is applied along with
+   * `Polymer.TemplateStamp`.
+   */
+  function GestureEventListeners<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+      _addEventListenerToNode(node: any, eventName: any, handler: any): any;
+      _removeEventListenerFromNode(node: any, eventName: any, handler: any): any;
+    }
+  } & T
+}
diff --git a/lib/mixins/mutable-data.d.ts b/lib/mixins/mutable-data.d.ts
new file mode 100644
index 0000000000..7876a77c80
--- /dev/null
+++ b/lib/mixins/mutable-data.d.ts
@@ -0,0 +1,137 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/mutable-data.html
+ */
+
+/// <reference path="../utils/mixin.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element class mixin to skip strict dirty-checking for objects and arrays
+   * (always consider them to be "dirty"), for use on elements utilizing
+   * `Polymer.PropertyEffects`
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will cause Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   * Specifically, any elements in the binding tree between the source of a
+   * mutation and the consumption of it must apply this mixin or enable the
+   * `Polymer.OptionalMutableData` mixin.
+   *
+   * In order to make the dirty check strategy configurable, see
+   * `Polymer.OptionalMutableData`.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse as opposed to using strict dirty checking with immutable
+   * patterns or Polymer's path notification API.
+   */
+  function MutableData<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+
+      /**
+       * Overrides `Polymer.PropertyEffects` to provide option for skipping
+       * strict equality checking for Objects and Arrays.
+       *
+       * This method pulls the value to dirty check against from the `__dataTemp`
+       * cache (rather than the normal `__data` cache) for Objects.  Since the temp
+       * cache is cleared at the end of a turn, this implementation allows
+       * side-effects of deep object changes to be processed by re-setting the
+       * same object (using the temp cache as an in-turn backstop to prevent
+       * cycles due to 2-way notification).
+       *
+       * @param property Property name
+       * @param value New property value
+       * @param old Previous property value
+       * @returns Whether the property should be considered a change
+       */
+      _shouldPropertyChange(property: string, value: any, old: any): boolean;
+    }
+  } & T
+
+  /**
+   * Element class mixin to add the optional ability to skip strict
+   * dirty-checking for objects and arrays (always consider them to be
+   * "dirty") by setting a `mutable-data` attribute on an element instance.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will allow Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   * Specifically, any elements in the binding tree between the source of a
+   * mutation and the consumption of it must enable this mixin or apply the
+   * `Polymer.MutableData` mixin.
+   *
+   * While this mixin adds the ability to forgo Object/Array dirty checking,
+   * the `mutableData` flag defaults to false and must be set on the instance.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse by relying on `mutableData: true` as opposed to using
+   * strict dirty checking with immutable patterns or Polymer's path notification
+   * API.
+   */
+  function OptionalMutableData<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+
+      /**
+       * Instance-level flag for configuring the dirty-checking strategy
+       * for this element.  When true, Objects and Arrays will skip dirty
+       * checking, otherwise strict equality checking will be used.
+       */
+      mutableData: boolean;
+
+      /**
+       * Overrides `Polymer.PropertyEffects` to provide option for skipping
+       * strict equality checking for Objects and Arrays.
+       *
+       * When `this.mutableData` is true on this instance, this method
+       * pulls the value to dirty check against from the `__dataTemp` cache
+       * (rather than the normal `__data` cache) for Objects.  Since the temp
+       * cache is cleared at the end of a turn, this implementation allows
+       * side-effects of deep object changes to be processed by re-setting the
+       * same object (using the temp cache as an in-turn backstop to prevent
+       * cycles due to 2-way notification).
+       *
+       * @param property Property name
+       * @param value New property value
+       * @param old Previous property value
+       * @returns Whether the property should be considered a change
+       */
+      _shouldPropertyChange(property: string, value: any, old: any): boolean;
+    }
+  } & T
+}
diff --git a/lib/mixins/property-accessors.d.ts b/lib/mixins/property-accessors.d.ts
new file mode 100644
index 0000000000..0794718766
--- /dev/null
+++ b/lib/mixins/property-accessors.d.ts
@@ -0,0 +1,297 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/property-accessors.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="../utils/case-map.d.ts" />
+/// <reference path="../utils/async.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element class mixin that provides basic meta-programming for creating one
+   * or more property accessors (getter/setter pair) that enqueue an async
+   * (batched) `_propertiesChanged` callback.
+   *
+   * For basic usage of this mixin, simply declare attributes to observe via
+   * the standard `static get observedAttributes()`, implement `_propertiesChanged`
+   * on the class, and then call `MyClass.createPropertiesForAttributes()` once
+   * on the class to generate property accessors for each observed attribute
+   * prior to instancing. Last, call `this._enableProperties()` in the element's
+   * `connectedCallback` to enable the accessors.
+   *
+   * Any `observedAttributes` will automatically be
+   * deserialized via `attributeChangedCallback` and set to the associated
+   * property using `dash-case`-to-`camelCase` convention.
+   */
+  function PropertyAccessors<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+      __serializing: boolean;
+      __dataCounter: number;
+      __dataEnabled: boolean;
+      __dataReady: boolean;
+      __dataInvalid: boolean;
+      __data: Object;
+      __dataPending: Object|null;
+      __dataOld: Object|null;
+      __dataProto: Object|null;
+      __dataHasAccessor: Object|null;
+      __dataInstanceProps: Object|null;
+
+      /**
+       * Implements native Custom Elements `attributeChangedCallback` to
+       * set an attribute value to a property via `_attributeToProperty`.
+       *
+       * @param name Name of attribute that changed
+       * @param old Old attribute value
+       * @param value New attribute value
+       */
+      attributeChangedCallback(name: string, old: string|null, value: string|null): any;
+
+      /**
+       * Initializes the local storage for property accessors.
+       *
+       * Provided as an override point for performing any setup work prior
+       * to initializing the property accessor system.
+       */
+      _initializeProperties(): any;
+
+      /**
+       * Called at instance time with bag of properties that were overwritten
+       * by accessors on the prototype when accessors were created.
+       *
+       * The default implementation sets these properties back into the
+       * setter at instance time.  This method is provided as an override
+       * point for customizing or providing more efficient initialization.
+       *
+       * @param props Bag of property values that were overwritten
+       *   when creating property accessors.
+       */
+      _initializeProtoProperties(props: Object|null): any;
+
+      /**
+       * Called at ready time with bag of instance properties that overwrote
+       * accessors when the element upgraded.
+       *
+       * The default implementation sets these properties back into the
+       * setter at ready time.  This method is provided as an override
+       * point for customizing or providing more efficient initialization.
+       *
+       * @param props Bag of property values that were overwritten
+       *   when creating property accessors.
+       */
+      _initializeInstanceProperties(props: Object|null): any;
+
+      /**
+       * Ensures the element has the given attribute. If it does not,
+       * assigns the given value to the attribute.
+       *
+       * @param attribute Name of attribute to ensure is set.
+       * @param value of the attribute.
+       */
+      _ensureAttribute(attribute: string, value: string): any;
+
+      /**
+       * Deserializes an attribute to its associated property.
+       *
+       * This method calls the `_deserializeValue` method to convert the string to
+       * a typed value.
+       *
+       * @param attribute Name of attribute to deserialize.
+       * @param value of the attribute.
+       * @param type type to deserialize to.
+       */
+      _attributeToProperty(attribute: string, value: string|null, type?: any): any;
+
+      /**
+       * Serializes a property to its associated attribute.
+       *
+       * @param property Property name to reflect.
+       * @param attribute Attribute name to reflect.
+       * @param value Property value to refect.
+       */
+      _propertyToAttribute(property: string, attribute?: string, value?: any): any;
+
+      /**
+       * Sets a typed value to an HTML attribute on a node.
+       *
+       * This method calls the `_serializeValue` method to convert the typed
+       * value to a string.  If the `_serializeValue` method returns `undefined`,
+       * the attribute will be removed (this is the default for boolean
+       * type `false`).
+       *
+       * @param node Element to set attribute to.
+       * @param value Value to serialize.
+       * @param attribute Attribute name to serialize to.
+       */
+      _valueToNodeAttribute(node: Element|null, value: any, attribute: string): any;
+
+      /**
+       * Converts a typed JavaScript value to a string.
+       *
+       * This method is called by Polymer when setting JS property values to
+       * HTML attributes.  Users may override this method on Polymer element
+       * prototypes to provide serialization for custom types.
+       *
+       * @param value Property value to serialize.
+       * @returns String serialized from the provided property value.
+       */
+      _serializeValue(value: any): string|undefined;
+
+      /**
+       * Converts a string to a typed JavaScript value.
+       *
+       * This method is called by Polymer when reading HTML attribute values to
+       * JS properties.  Users may override this method on Polymer element
+       * prototypes to provide deserialization for custom `type`s.  Note,
+       * the `type` argument is the value of the `type` field provided in the
+       * `properties` configuration object for a given property, and is
+       * by convention the constructor for the type to deserialize.
+       *
+       * Note: The return value of `undefined` is used as a sentinel value to
+       * indicate the attribute should be removed.
+       *
+       * @param value Attribute value to deserialize.
+       * @param type Type to deserialize the string to.
+       * @returns Typed value deserialized from the provided string.
+       */
+      _deserializeValue(value: string|null, type?: any): any;
+
+      /**
+       * Creates a setter/getter pair for the named property with its own
+       * local storage.  The getter returns the value in the local storage,
+       * and the setter calls `_setProperty`, which updates the local storage
+       * for the property and enqueues a `_propertiesChanged` callback.
+       *
+       * This method may be called on a prototype or an instance.  Calling
+       * this method may overwrite a property value that already exists on
+       * the prototype/instance by creating the accessor.  When calling on
+       * a prototype, any overwritten values are saved in `__dataProto`,
+       * and it is up to the subclasser to decide how/when to set those
+       * properties back into the accessor.  When calling on an instance,
+       * the overwritten value is set via `_setPendingProperty`, and the
+       * user should call `_invalidateProperties` or `_flushProperties`
+       * for the values to take effect.
+       *
+       * @param property Name of the property
+       * @param readOnly When true, no setter is created; the
+       *   protected `_setProperty` function must be used to set the property
+       */
+      _createPropertyAccessor(property: string, readOnly?: boolean): any;
+
+      /**
+       * Returns true if this library created an accessor for the given property.
+       *
+       * @param property Property name
+       * @returns True if an accessor was created
+       */
+      _hasAccessor(property: string): boolean;
+
+      /**
+       * Updates the local storage for a property (via `_setPendingProperty`)
+       * and enqueues a `_propertiesChanged` callback.
+       *
+       * @param property Name of the property
+       * @param value Value to set
+       */
+      _setProperty(property: string, value: any): any;
+
+      /**
+       * Updates the local storage for a property, records the previous value,
+       * and adds it to the set of "pending changes" that will be passed to the
+       * `_propertiesChanged` callback.  This method does not enqueue the
+       * `_propertiesChanged` callback.
+       *
+       * @param property Name of the property
+       * @param value Value to set
+       * @returns Returns true if the property changed
+       */
+      _setPendingProperty(property: string, value: any): boolean;
+
+      /**
+       * Returns true if the specified property has a pending change.
+       *
+       * @param prop Property name
+       * @returns True if property has a pending change
+       */
+      _isPropertyPending(prop: string): boolean;
+
+      /**
+       * Marks the properties as invalid, and enqueues an async
+       * `_propertiesChanged` callback.
+       */
+      _invalidateProperties(): any;
+
+      /**
+       * Call to enable property accessor processing. Before this method is
+       * called accessor values will be set but side effects are
+       * queued. When called, any pending side effects occur immediately.
+       * For elements, generally `connectedCallback` is a normal spot to do so.
+       * It is safe to call this method multiple times as it only turns on
+       * property accessors once.
+       */
+      _enableProperties(): any;
+
+      /**
+       * Calls the `_propertiesChanged` callback with the current set of
+       * pending changes (and old values recorded when pending changes were
+       * set), and resets the pending set of changes. Generally, this method
+       * should not be called in user code.
+       */
+      _flushProperties(): any;
+
+      /**
+       * Lifecycle callback called the first time properties are being flushed.
+       * Prior to `ready`, all property sets through accessors are queued and
+       * their effects are flushed after this method returns.
+       *
+       * Users may override this function to implement behavior that is
+       * dependent on the element having its properties initialized, e.g.
+       * from defaults (initialized from `constructor`, `_initializeProperties`),
+       * `attributeChangedCallback`, or values propagated from host e.g. via
+       * bindings.  `super.ready()` must be called to ensure the data system
+       * becomes enabled.
+       */
+      ready(): any;
+
+      /**
+       * Callback called when any properties with accessors created via
+       * `_createPropertyAccessor` have been set.
+       *
+       * @param currentProps Bag of all current accessor values
+       * @param changedProps Bag of properties changed since the last
+       *   call to `_propertiesChanged`
+       * @param oldProps Bag of previous values for each property
+       *   in `changedProps`
+       */
+      _propertiesChanged(currentProps: Object, changedProps: Object, oldProps: Object): any;
+
+      /**
+       * Method called to determine whether a property value should be
+       * considered as a change and cause the `_propertiesChanged` callback
+       * to be enqueued.
+       *
+       * The default implementation returns `true` for primitive types if a
+       * strict equality check fails, and returns `true` for all Object/Arrays.
+       * The method always returns false for `NaN`.
+       *
+       * Override this method to e.g. provide stricter checking for
+       * Objects/Arrays when using immutable patterns.
+       *
+       * @param property Property name
+       * @param value New property value
+       * @param old Previous property value
+       * @returns Whether the property should be considered a change
+       *   and enqueue a `_propertiesChanged` callback
+       */
+      _shouldPropertyChange(property: string, value: any, old: any): boolean;
+    }
+  } & T
+}
diff --git a/lib/mixins/property-effects.d.ts b/lib/mixins/property-effects.d.ts
new file mode 100644
index 0000000000..4060156f0d
--- /dev/null
+++ b/lib/mixins/property-effects.d.ts
@@ -0,0 +1,619 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/property-effects.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="../utils/path.d.ts" />
+/// <reference path="../utils/case-map.d.ts" />
+/// <reference path="property-accessors.d.ts" />
+/// <reference path="template-stamp.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element class mixin that provides meta-programming for Polymer's template
+   * binding and data observation (collectively, "property effects") system.
+   *
+   * This mixin uses provides the following key static methods for adding
+   * property effects to an element class:
+   * - `addPropertyEffect`
+   * - `createPropertyObserver`
+   * - `createMethodObserver`
+   * - `createNotifyingProperty`
+   * - `createReadOnlyProperty`
+   * - `createReflectedProperty`
+   * - `createComputedProperty`
+   * - `bindTemplate`
+   *
+   * Each method creates one or more property accessors, along with metadata
+   * used by this mixin's implementation of `_propertiesChanged` to perform
+   * the property effects.
+   *
+   * Underscored versions of the above methods also exist on the element
+   * prototype for adding property effects on instances at runtime.
+   *
+   * Note that this mixin overrides several `PropertyAccessors` methods, in
+   * many cases to maintain guarantees provided by the Polymer 1.x features;
+   * notably it changes property accessors to be synchronous by default
+   * whereas the default when using `PropertyAccessors` standalone is to be
+   * async by default.
+   */
+  function PropertyEffects<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+      __dataCounter: number;
+      __data: Object;
+      __dataPending: Object;
+      __dataOld: Object;
+      __dataClientsReady: boolean;
+      __dataPendingClients: any[]|null;
+      __dataToNotify: Object|null;
+      __dataLinkedPaths: Object|null;
+      __dataHasPaths: boolean;
+      __dataCompoundStorage: Object|null;
+      __dataHost: Polymer_PropertyEffects|null;
+      __dataTemp: Object;
+      __dataClientsInitialized: boolean;
+      __computeEffects: Object|null;
+      __reflectEffects: Object|null;
+      __notifyEffects: Object|null;
+      __propagateEffects: Object|null;
+      __observeEffects: Object|null;
+      __readOnly: Object|null;
+      __templateInfo: TemplateInfo;
+
+      /**
+       * Stamps the provided template and performs instance-time setup for
+       * Polymer template features, including data bindings, declarative event
+       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
+       * is returned containing the stamped DOM, ready for insertion into the
+       * DOM.
+       *
+       * This method may be called more than once; however note that due to
+       * `shadycss` polyfill limitations, only styles from templates prepared
+       * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped
+       * to the shadow root and support CSS custom properties), and note that
+       * `ShadyCSS.prepareTemplate` may only be called once per element. As such,
+       * any styles required by in runtime-stamped templates must be included
+       * in the main element template.
+       *
+       * @param template Template to stamp
+       * @returns Cloned template content
+       */
+      _stampTemplate(template: HTMLTemplateElement): StampedTemplate;
+      _initializeProperties(): any;
+
+      /**
+       * Overrides `Polymer.PropertyAccessors` implementation to provide a
+       * more efficient implementation of initializing properties from
+       * the prototype on the instance.
+       *
+       * @param props Properties to initialize on the prototype
+       */
+      _initializeProtoProperties(props: Object|null): any;
+
+      /**
+       * Overrides `Polymer.PropertyAccessors` implementation to avoid setting
+       * `_setProperty`'s `shouldNotify: true`.
+       *
+       * @param props Properties to initialize on the instance
+       */
+      _initializeInstanceProperties(props: Object|null): any;
+
+      /**
+       * Overrides base implementation to ensure all accessors set `shouldNotify`
+       * to true, for per-property notification tracking.
+       */
+      _setProperty(property: any, value: any): any;
+
+      /**
+       * Overrides the `PropertyAccessors` implementation to introduce special
+       * dirty check logic depending on the property & value being set:
+       *
+       * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})
+       *    Stored in `__dataTemp`, dirty checked against `__dataTemp`
+       * 2. Object set to simple property (e.g. 'prop': {...})
+       *    Stored in `__dataTemp` and `__data`, dirty checked against
+       *    `__dataTemp` by default implementation of `_shouldPropertyChange`
+       * 3. Primitive value set to simple property (e.g. 'prop': 42)
+       *    Stored in `__data`, dirty checked against `__data`
+       *
+       * The dirty-check is important to prevent cycles due to two-way
+       * notification, but paths and objects are only dirty checked against any
+       * previous value set during this turn via a "temporary cache" that is
+       * cleared when the last `_propertiesChanged` exits. This is so:
+       * a. any cached array paths (e.g. 'array.3.prop') may be invalidated
+       *    due to array mutations like shift/unshift/splice; this is fine
+       *    since path changes are dirty-checked at user entry points like `set`
+       * b. dirty-checking for objects only lasts one turn to allow the user
+       *    to mutate the object in-place and re-set it with the same identity
+       *    and have all sub-properties re-propagated in a subsequent turn.
+       *
+       * The temp cache is not necessarily sufficient to prevent invalid array
+       * paths, since a splice can happen during the same turn (with pathological
+       * user code); we could introduce a "fixup" for temporarily cached array
+       * paths if needed: https://github.com/Polymer/polymer/issues/4227
+       *
+       * @param property Name of the property
+       * @param value Value to set
+       * @param shouldNotify True if property should fire notification
+       *   event (applies only for `notify: true` properties)
+       * @returns Returns true if the property changed
+       */
+      _setPendingProperty(property: string, value: any, shouldNotify?: boolean): boolean;
+
+      /**
+       * Overrides `PropertyAccessor`'s default async queuing of
+       * `_propertiesChanged`: if `__dataReady` is false (has not yet been
+       * manually flushed), the function no-ops; otherwise flushes
+       * `_propertiesChanged` synchronously.
+       */
+      _invalidateProperties(): any;
+
+      /**
+       * Overrides `PropertyAccessors` so that property accessor
+       * side effects are not enabled until after client dom is fully ready.
+       * Also calls `_flushClients` callback to ensure client dom is enabled
+       * that was not enabled as a result of flushing properties.
+       */
+      ready(): any;
+
+      /**
+       * Implements `PropertyAccessors`'s properties changed callback.
+       *
+       * Runs each class of effects for the batch of changed properties in
+       * a specific order (compute, propagate, reflect, observe, notify).
+       */
+      _propertiesChanged(currentProps: any, changedProps: any, oldProps: any): any;
+
+      /**
+       * Equivalent to static `addPropertyEffect` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * @param property Property that should trigger the effect
+       * @param type Effect type, from this.PROPERTY_EFFECT_TYPES
+       * @param effect Effect metadata object
+       */
+      _addPropertyEffect(property: string, type: string, effect?: Object|null): any;
+
+      /**
+       * Removes the given property effect.
+       *
+       * @param property Property the effect was associated with
+       * @param type Effect type, from this.PROPERTY_EFFECT_TYPES
+       * @param effect Effect metadata object to remove
+       */
+      _removePropertyEffect(property: string, type: string, effect?: Object|null): any;
+
+      /**
+       * Returns whether the current prototype/instance has a property effect
+       * of a certain type.
+       *
+       * @param property Property name
+       * @param type Effect type, from this.PROPERTY_EFFECT_TYPES
+       * @returns True if the prototype/instance has an effect of this type
+       */
+      _hasPropertyEffect(property: string, type?: string): boolean;
+
+      /**
+       * Returns whether the current prototype/instance has a "read only"
+       * accessor for the given property.
+       *
+       * @param property Property name
+       * @returns True if the prototype/instance has an effect of this type
+       */
+      _hasReadOnlyEffect(property: string): boolean;
+
+      /**
+       * Returns whether the current prototype/instance has a "notify"
+       * property effect for the given property.
+       *
+       * @param property Property name
+       * @returns True if the prototype/instance has an effect of this type
+       */
+      _hasNotifyEffect(property: string): boolean;
+
+      /**
+       * Returns whether the current prototype/instance has a "reflect to attribute"
+       * property effect for the given property.
+       *
+       * @param property Property name
+       * @returns True if the prototype/instance has an effect of this type
+       */
+      _hasReflectEffect(property: string): boolean;
+
+      /**
+       * Returns whether the current prototype/instance has a "computed"
+       * property effect for the given property.
+       *
+       * @param property Property name
+       * @returns True if the prototype/instance has an effect of this type
+       */
+      _hasComputedEffect(property: string): boolean;
+
+      /**
+       * Sets a pending property or path.  If the root property of the path in
+       * question had no accessor, the path is set, otherwise it is enqueued
+       * via `_setPendingProperty`.
+       *
+       * This function isolates relatively expensive functionality necessary
+       * for the public API (`set`, `setProperties`, `notifyPath`, and property
+       * change listeners via {{...}} bindings), such that it is only done
+       * when paths enter the system, and not at every propagation step.  It
+       * also sets a `__dataHasPaths` flag on the instance which is used to
+       * fast-path slower path-matching code in the property effects host paths.
+       *
+       * `path` can be a path string or array of path parts as accepted by the
+       * public API.
+       *
+       * @param path Path to set
+       * @param value Value to set
+       * @param shouldNotify Set to true if this change should
+       *  cause a property notification event dispatch
+       * @param isPathNotification If the path being set is a path
+       *   notification of an already changed value, as opposed to a request
+       *   to set and notify the change.  In the latter `false` case, a dirty
+       *   check is performed and then the value is set to the path before
+       *   enqueuing the pending property change.
+       * @returns Returns true if the property/path was enqueued in
+       *   the pending changes bag.
+       */
+      _setPendingPropertyOrPath(path: string|Array<number|string>, value: any, shouldNotify?: boolean, isPathNotification?: boolean): boolean;
+
+      /**
+       * Applies a value to a non-Polymer element/node's property.
+       *
+       * The implementation makes a best-effort at binding interop:
+       * Some native element properties have side-effects when
+       * re-setting the same value (e.g. setting `<input>.value` resets the
+       * cursor position), so we do a dirty-check before setting the value.
+       * However, for better interop with non-Polymer custom elements that
+       * accept objects, we explicitly re-set object changes coming from the
+       * Polymer world (which may include deep object changes without the
+       * top reference changing), erring on the side of providing more
+       * information.
+       *
+       * Users may override this method to provide alternate approaches.
+       *
+       * @param node The node to set a property on
+       * @param prop The property to set
+       * @param value The value to set
+       */
+      _setUnmanagedPropertyToNode(node: Node|null, prop: string, value: any): any;
+
+      /**
+       * Enqueues the given client on a list of pending clients, whose
+       * pending property changes can later be flushed via a call to
+       * `_flushClients`.
+       *
+       * @param client PropertyEffects client to enqueue
+       */
+      _enqueueClient(client: Object|null): any;
+
+      /**
+       * Flushes any clients previously enqueued via `_enqueueClient`, causing
+       * their `_flushProperties` method to run.
+       */
+      _flushClients(): any;
+
+      /**
+       * (c) the stamped dom enables.
+       */
+      __enableOrFlushClients(): any;
+
+      /**
+       * Perform any initial setup on client dom. Called before the first
+       * `_flushProperties` call on client dom and before any element
+       * observers are called.
+       */
+      _readyClients(): any;
+
+      /**
+       * Sets a bag of property changes to this instance, and
+       * synchronously processes all effects of the properties as a batch.
+       *
+       * Property names must be simple properties, not paths.  Batched
+       * path propagation is not supported.
+       *
+       * @param props Bag of one or more key-value pairs whose key is
+       *   a property and value is the new value to set for that property.
+       * @param setReadOnly When true, any private values set in
+       *   `props` will be set. By default, `setProperties` will not set
+       *   `readOnly: true` root properties.
+       */
+      setProperties(props: Object|null, setReadOnly?: boolean): any;
+
+      /**
+       * Called to propagate any property changes to stamped template nodes
+       * managed by this element.
+       *
+       * @param changedProps Bag of changed properties
+       * @param oldProps Bag of previous values for changed properties
+       * @param hasPaths True with `props` contains one or more paths
+       */
+      _propagatePropertyChanges(changedProps: Object|null, oldProps: Object|null, hasPaths: boolean): any;
+
+      /**
+       * Aliases one data path as another, such that path notifications from one
+       * are routed to the other.
+       *
+       * @param to Target path to link.
+       * @param from Source path to link.
+       */
+      linkPaths(to: string|Array<string|number>, from: string|Array<string|number>): any;
+
+      /**
+       * Removes a data path alias previously established with `_linkPaths`.
+       *
+       * Note, the path to unlink should be the target (`to`) used when
+       * linking the paths.
+       *
+       * @param path Target path to unlink.
+       */
+      unlinkPaths(path: string|Array<string|number>): any;
+
+      /**
+       * Notify that an array has changed.
+       *
+       * Example:
+       *
+       *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];
+       *     ...
+       *     this.items.splice(1, 1, {name: 'Sam'});
+       *     this.items.push({name: 'Bob'});
+       *     this.notifySplices('items', [
+       *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1, object: this.items, type: 'splice' },
+       *       { index: 3, removed: [], addedCount: 1, object: this.items, type: 'splice'}
+       *     ]);
+       *
+       * @param path Path that should be notified.
+       * @param splices Array of splice records indicating ordered
+       *   changes that occurred to the array. Each record should have the
+       *   following fields:
+       *    * index: index at which the change occurred
+       *    * removed: array of items that were removed from this index
+       *    * addedCount: number of new items added at this index
+       *    * object: a reference to the array in question
+       *    * type: the string literal 'splice'
+       *
+       *   Note that splice records _must_ be normalized such that they are
+       *   reported in index order (raw results from `Object.observe` are not
+       *   ordered and must be normalized/merged before notifying).
+       */
+      notifySplices(path: string, splices: any[]|null): any;
+
+      /**
+       * Convenience method for reading a value from a path.
+       *
+       * Note, if any part in the path is undefined, this method returns
+       * `undefined` (this method does not throw when dereferencing undefined
+       * paths).
+       *
+       * @param path Path to the value
+       *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
+       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+       *   bracketed expressions are not supported; string-based path parts
+       *   *must* be separated by dots.  Note that when dereferencing array
+       *   indices, the index may be used as a dotted part directly
+       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
+       * @param root Root object from which the path is evaluated.
+       * @returns Value at the path, or `undefined` if any part of the path
+       *   is undefined.
+       */
+      get(path: string|Array<string|number>, root?: Object|null): any;
+
+      /**
+       * Convenience method for setting a value to a path and notifying any
+       * elements bound to the same path.
+       *
+       * Note, if any part in the path except for the last is undefined,
+       * this method does nothing (this method does not throw when
+       * dereferencing undefined paths).
+       *
+       * @param path Path to the value
+       *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)
+       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
+       *   bracketed expressions are not supported; string-based path parts
+       *   *must* be separated by dots.  Note that when dereferencing array
+       *   indices, the index may be used as a dotted part directly
+       *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).
+       * @param value Value to set at the specified path.
+       * @param root Root object from which the path is evaluated.
+       *   When specified, no notification will occur.
+       */
+      set(path: string|Array<string|number>, value: any, root?: Object|null): any;
+
+      /**
+       * Adds items onto the end of the array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.push`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @param path Path to array.
+       * @param items Items to push onto array
+       * @returns New length of the array.
+       */
+      push(path: string|Array<string|number>, ...items: any[]): number;
+
+      /**
+       * Removes an item from the end of array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.pop`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @param path Path to array.
+       * @returns Item that was removed.
+       */
+      pop(path: string|Array<string|number>): any;
+
+      /**
+       * Starting from the start index specified, removes 0 or more items
+       * from the array and inserts 0 or more new items in their place.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.splice`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @param path Path to array.
+       * @param start Index from which to start removing/inserting.
+       * @param deleteCount Number of items to remove.
+       * @param items Items to insert into array.
+       * @returns Array of removed items.
+       */
+      splice(path: string|Array<string|number>, start: number, deleteCount: number, ...items: any[]): any[]|null;
+
+      /**
+       * Removes an item from the beginning of array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.pop`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @param path Path to array.
+       * @returns Item that was removed.
+       */
+      shift(path: string|Array<string|number>): any;
+
+      /**
+       * Adds items onto the beginning of the array at the path specified.
+       *
+       * The arguments after `path` and return value match that of
+       * `Array.prototype.push`.
+       *
+       * This method notifies other paths to the same array that a
+       * splice occurred to the array.
+       *
+       * @param path Path to array.
+       * @param items Items to insert info array
+       * @returns New length of the array.
+       */
+      unshift(path: string|Array<string|number>, ...items: any[]): number;
+
+      /**
+       * Notify that a path has changed.
+       *
+       * Example:
+       *
+       *     this.item.user.name = 'Bob';
+       *     this.notifyPath('item.user.name');
+       *
+       * @param path Path that should be notified.
+       * @param value Value at the path (optional).
+       */
+      notifyPath(path: string, value?: any): any;
+
+      /**
+       * Equivalent to static `createReadOnlyProperty` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * @param property Property name
+       * @param protectedSetter Creates a custom protected setter
+       *   when `true`.
+       */
+      _createReadOnlyProperty(property: string, protectedSetter?: boolean): any;
+
+      /**
+       * Equivalent to static `createPropertyObserver` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * @param property Property name
+       * @param methodName Name of observer method to call
+       * @param dynamicFn Whether the method name should be included as
+       *   a dependency to the effect.
+       */
+      _createPropertyObserver(property: string, methodName: string, dynamicFn?: boolean): any;
+
+      /**
+       * Equivalent to static `createMethodObserver` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * @param expression Method expression
+       * @param dynamicFn Boolean or object map indicating
+       *   whether method names should be included as a dependency to the effect.
+       */
+      _createMethodObserver(expression: string, dynamicFn?: boolean|Object|null): any;
+
+      /**
+       * Equivalent to static `createNotifyingProperty` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * @param property Property name
+       */
+      _createNotifyingProperty(property: string): any;
+
+      /**
+       * Equivalent to static `createReflectedProperty` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * @param property Property name
+       */
+      _createReflectedProperty(property: string): any;
+
+      /**
+       * Equivalent to static `createComputedProperty` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * @param property Name of computed property to set
+       * @param expression Method expression
+       * @param dynamicFn Boolean or object map indicating
+       *   whether method names should be included as a dependency to the effect.
+       */
+      _createComputedProperty(property: string, expression: string, dynamicFn?: boolean|Object|null): any;
+
+      /**
+       * Equivalent to static `bindTemplate` API but can be called on
+       * an instance to add effects at runtime.  See that method for
+       * full API docs.
+       *
+       * This method may be called on the prototype (for prototypical template
+       * binding, to avoid creating accessors every instance) once per prototype,
+       * and will be called with `runtimeBinding: true` by `_stampTemplate` to
+       * create and link an instance of the template metadata associated with a
+       * particular stamping.
+       *
+       * @param template Template containing binding
+       *   bindings
+       * @param instanceBinding When false (default), performs
+       *   "prototypical" binding of the template and overwrites any previously
+       *   bound template for the class. When true (as passed from
+       *   `_stampTemplate`), the template info is instanced and linked into
+       *   the list of bound templates.
+       * @returns Template metadata object; for `runtimeBinding`,
+       *   this is an instance of the prototypical template info
+       */
+      _bindTemplate(template: HTMLTemplateElement|null, instanceBinding?: boolean): TemplateInfo;
+
+      /**
+       * Removes and unbinds the nodes previously contained in the provided
+       * DocumentFragment returned from `_stampTemplate`.
+       *
+       * @param dom DocumentFragment previously returned
+       *   from `_stampTemplate` associated with the nodes to be removed
+       */
+      _removeBoundDom(dom: StampedTemplate): any;
+    }
+  } & T
+}
diff --git a/lib/mixins/template-stamp.d.ts b/lib/mixins/template-stamp.d.ts
new file mode 100644
index 0000000000..493257ef85
--- /dev/null
+++ b/lib/mixins/template-stamp.d.ts
@@ -0,0 +1,86 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/template-stamp.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Element mixin that provides basic template parsing and stamping, including
+   * the following template-related features for stamped templates:
+   *
+   * - Declarative event listeners (`on-eventname="listener"`)
+   * - Map of node id's to stamped node instances (`this.$.id`)
+   * - Nested template content caching/removal and re-installation (performance
+   *   optimization)
+   */
+  function TemplateStamp<T extends new(...args: any[]) => {}>(base: T): {
+    new(...args: any[]): {
+
+      /**
+       * Clones the provided template content and returns a document fragment
+       * containing the cloned dom.
+       *
+       * The template is parsed (once and memoized) using this library's
+       * template parsing features, and provides the following value-added
+       * features:
+       * * Adds declarative event listeners for `on-event="handler"` attributes
+       * * Generates an "id map" for all nodes with id's under `$` on returned
+       *   document fragment
+       * * Passes template info including `content` back to templates as
+       *   `_templateInfo` (a performance optimization to avoid deep template
+       *   cloning)
+       *
+       * Note that the memoized template parsing process is destructive to the
+       * template: attributes for bindings and declarative event listeners are
+       * removed after being noted in notes, and any nested `<template>.content`
+       * is removed and stored in notes as well.
+       *
+       * @param template Template to stamp
+       * @returns Cloned template content
+       */
+      _stampTemplate(template: HTMLTemplateElement): StampedTemplate;
+
+      /**
+       * Adds an event listener by method name for the event provided.
+       *
+       * This method generates a handler function that looks up the method
+       * name at handling time.
+       *
+       * @param node Node to add listener on
+       * @param eventName Name of event
+       * @param methodName Name of method
+       * @param context Context the method will be called on (defaults
+       *   to `node`)
+       * @returns Generated handler function
+       */
+      _addMethodEventListenerToNode(node: Node|null, eventName: string, methodName: string, context?: any): Function|null;
+
+      /**
+       * Override point for adding custom or simulated event handling.
+       *
+       * @param node Node to add event listener to
+       * @param eventName Name of event
+       * @param handler Listener function to add
+       */
+      _addEventListenerToNode(node: Node|null, eventName: string, handler: Function|null): any;
+
+      /**
+       * Override point for adding custom or simulated event handling.
+       *
+       * @param node Node to remove event listener from
+       * @param eventName Name of event
+       * @param handler Listener function to remove
+       */
+      _removeEventListenerFromNode(node: Node|null, eventName: string, handler: Function|null): any;
+    }
+  } & T
+}
diff --git a/lib/utils/array-splice.d.ts b/lib/utils/array-splice.d.ts
new file mode 100644
index 0000000000..18f38d76c9
--- /dev/null
+++ b/lib/utils/array-splice.d.ts
@@ -0,0 +1,41 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/array-splice.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+  namespace ArraySplice {
+
+
+    /**
+     * Returns an array of splice records indicating the minimum edits required
+     * to transform the `previous` array into the `current` array.
+     *
+     * Splice records are ordered by index and contain the following fields:
+     * - `index`: index where edit started
+     * - `removed`: array of removed items from this index
+     * - `addedCount`: number of items added at this index
+     *
+     * This function is based on the Levenshtein "minimum edit distance"
+     * algorithm. Note that updates are treated as removal followed by addition.
+     *
+     * The worst-case time complexity of this algorithm is `O(l * p)`
+     *   l: The length of the current array
+     *   p: The length of the previous array
+     *
+     * However, the worst-case complexity is reduced by an `O(n)` optimization
+     * to detect any shared prefix & suffix between the two arrays and only
+     * perform the more expensive minimum edit distance calculation over the
+     * non-shared portions of the arrays.
+     */
+    function calculateSplices(current: any[]|null, previous: any[]|null): any[]|null;
+  }
+}
diff --git a/lib/utils/async.d.ts b/lib/utils/async.d.ts
new file mode 100644
index 0000000000..516193e7a7
--- /dev/null
+++ b/lib/utils/async.d.ts
@@ -0,0 +1,84 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/async.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+  namespace Async {
+
+    namespace timeOut {
+
+
+      /**
+       * Returns a sub-module with the async interface providing the provided
+       * delay.
+       */
+      function after(delay: number): AsyncInterface|null;
+
+
+      /**
+       * Enqueues a function called in the next task.
+       */
+      function run(fn: Function|null): number;
+
+
+      /**
+       * Cancels a previously enqueued `timeOut` callback.
+       */
+      function cancel(handle: number): any;
+
+
+      /**
+       * Cancels a previously enqueued `animationFrame` callback.
+       */
+      function cancel(handle: number): any;
+    }
+
+    namespace animationFrame {
+
+
+      /**
+       * Enqueues a function called at `requestAnimationFrame` timing.
+       */
+      function run(fn: Function|null): number;
+    }
+
+    namespace idlePeriod {
+
+
+      /**
+       * Enqueues a function called at `requestIdleCallback` timing.
+       */
+      function run(fn: (p0: IdleDeadline|null) => any): number;
+
+
+      /**
+       * Cancels a previously enqueued `idlePeriod` callback.
+       */
+      function cancel(handle: number): any;
+    }
+
+    namespace microTask {
+
+
+      /**
+       * Enqueues a function called at microtask timing.
+       */
+      function run(callback: Function|null): number;
+
+
+      /**
+       * Cancels a previously enqueued `microTask` callback.
+       */
+      function cancel(handle: number): any;
+    }
+  }
+}
diff --git a/lib/utils/boot.d.ts b/lib/utils/boot.d.ts
new file mode 100644
index 0000000000..9372cfa6f8
--- /dev/null
+++ b/lib/utils/boot.d.ts
@@ -0,0 +1,10 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/boot.html
+ */
+
diff --git a/lib/utils/case-map.d.ts b/lib/utils/case-map.d.ts
new file mode 100644
index 0000000000..ea7d97d3f1
--- /dev/null
+++ b/lib/utils/case-map.d.ts
@@ -0,0 +1,31 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/case-map.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+  namespace CaseMap {
+
+
+    /**
+     * Converts "dash-case" identifier (e.g. `foo-bar-baz`) to "camelCase"
+     * (e.g. `fooBarBaz`).
+     */
+    function dashToCamelCase(dash: string): string;
+
+
+    /**
+     * Converts "camelCase" identifier (e.g. `fooBarBaz`) to "dash-case"
+     * (e.g. `foo-bar-baz`).
+     */
+    function camelToDashCase(camel: string): string;
+  }
+}
diff --git a/lib/utils/debounce.d.ts b/lib/utils/debounce.d.ts
new file mode 100644
index 0000000000..9e9ccbb115
--- /dev/null
+++ b/lib/utils/debounce.d.ts
@@ -0,0 +1,46 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/debounce.html
+ */
+
+/// <reference path="boot.d.ts" />
+/// <reference path="mixin.d.ts" />
+/// <reference path="async.d.ts" />
+
+declare namespace Polymer {
+
+  class Debouncer {
+
+    /**
+     * Sets the scheduler; that is, a module with the Async interface,
+     * a callback and optional arguments to be passed to the run function
+     * from the async module.
+     *
+     * @param asyncModule Object with Async interface.
+     * @param callback Callback to run.
+     */
+    setConfig(asyncModule: AsyncModule, callback: () => any): any;
+
+    /**
+     * Cancels an active debouncer and returns a reference to itself.
+     */
+    cancel(): any;
+
+    /**
+     * Flushes an active debouncer and returns a reference to itself.
+     */
+    flush(): any;
+
+    /**
+     * Returns true if the debouncer is active.
+     *
+     * @returns True if active.
+     */
+    isActive(): boolean;
+  }
+}
diff --git a/lib/utils/flattened-nodes-observer.d.ts b/lib/utils/flattened-nodes-observer.d.ts
new file mode 100644
index 0000000000..43f5706291
--- /dev/null
+++ b/lib/utils/flattened-nodes-observer.d.ts
@@ -0,0 +1,72 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/flattened-nodes-observer.html
+ */
+
+/// <reference path="boot.d.ts" />
+/// <reference path="array-splice.d.ts" />
+/// <reference path="async.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Class that listens for changes (additions or removals) to
+   * "flattened nodes" on a given `node`. The list of flattened nodes consists
+   * of a node's children and, for any children that are `<slot>` elements,
+   * the expanded flattened list of `assignedNodes`.
+   * For example, if the observed node has children `<a></a><slot></slot><b></b>`
+   * and the `<slot>` has one `<div>` assigned to it, then the flattened
+   * nodes list is `<a></a><div></div><b></b>`. If the `<slot>` has other
+   * `<slot>` elements assigned to it, these are flattened as well.
+   *
+   * The provided `callback` is called whenever any change to this list
+   * of flattened nodes occurs, where an addition or removal of a node is
+   * considered a change. The `callback` is called with one argument, an object
+   * containing an array of any `addedNodes` and `removedNodes`.
+   *
+   * Note: the callback is called asynchronous to any changes
+   * at a microtask checkpoint. This is because observation is performed using
+   * `MutationObserver` and the `<slot>` element's `slotchange` event which
+   * are asynchronous.
+   */
+  class FlattenedNodesObserver {
+    _shadyChildrenObserver: MutationObserver|null;
+    _nativeChildrenObserver: MutationObserver|null;
+    _boundSchedule: () => any;
+
+    /**
+     * Activates an observer. This method is automatically called when
+     * a `FlattenedNodesObserver` is created. It should only be called to
+     * re-activate an observer that has been deactivated via the `disconnect` method.
+     */
+    connect(): any;
+
+    /**
+     * Deactivates the flattened nodes observer. After calling this method
+     * the observer callback will not be called when changes to flattened nodes
+     * occur. The `connect` method may be subsequently called to reactivate
+     * the observer.
+     */
+    disconnect(): any;
+    _schedule(): any;
+    _processMutations(mutations: any): any;
+    _processSlotMutations(mutations: any): any;
+
+    /**
+     * Flushes the observer causing any pending changes to be immediately
+     * delivered the observer callback. By default these changes are delivered
+     * asynchronously at the next microtask checkpoint.
+     *
+     * @returns Returns true if any pending changes caused the observer
+     * callback to run.
+     */
+    flush(): boolean;
+    _listenSlots(nodeList: any): any;
+    _unlistenSlots(nodeList: any): any;
+  }
+}
diff --git a/lib/utils/flush.d.ts b/lib/utils/flush.d.ts
new file mode 100644
index 0000000000..2c47af522a
--- /dev/null
+++ b/lib/utils/flush.d.ts
@@ -0,0 +1,28 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/flush.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+
+  /**
+   * Adds a `Polymer.Debouncer` to a list of globally flushable tasks.
+   */
+  function enqueueDebouncer(debouncer: Polymer.Debouncer|null): any;
+
+
+  /**
+   * Forces several classes of asynchronously queued tasks to flush:
+   * - Debouncers added via `enqueueDebouncer`
+   * - ShadyDOM distribution
+   */
+  function flush(): any;
+}
diff --git a/lib/utils/gestures.d.ts b/lib/utils/gestures.d.ts
new file mode 100644
index 0000000000..8f1720d082
--- /dev/null
+++ b/lib/utils/gestures.d.ts
@@ -0,0 +1,72 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/gestures.html
+ */
+
+/// <reference path="boot.d.ts" />
+/// <reference path="async.d.ts" />
+/// <reference path="debounce.d.ts" />
+
+declare namespace Polymer {
+
+  namespace Gestures {
+
+
+    /**
+     * Finds the element rendered on the screen at the provided coordinates.
+     *
+     * Similar to `document.elementFromPoint`, but pierces through
+     * shadow roots.
+     */
+    function deepTargetFind(x: number, y: number): Element|null;
+
+
+    /**
+     * Adds an event listener to a node for the given gesture type.
+     */
+    function addListener(node: Node|null, evType: string, handler: Function|null): boolean;
+
+
+    /**
+     * Removes an event listener from a node for the given gesture type.
+     */
+    function removeListener(node: Node|null, evType: string, handler: Function|null): boolean;
+
+
+    /**
+     * Registers a new gesture event recognizer for adding new custom
+     * gesture event types.
+     */
+    function register(recog: GestureRecognizer|null): any;
+
+
+    /**
+     * Sets scrolling direction on node.
+     *
+     * This value is checked on first move, thus it should be called prior to
+     * adding event listeners.
+     */
+    function setTouchAction(node: Element|null, value: string): any;
+
+
+    /**
+     * Prevents the dispatch and default action of the given event name.
+     */
+    function prevent(evName: string): any;
+
+
+    /**
+     * Reset the 2500ms timeout on processing mouse input after detecting touch input.
+     *
+     * Touch inputs create synthesized mouse inputs anywhere from 0 to 2000ms after the touch.
+     * This method should only be called during testing with simulated touch inputs.
+     * Calling this method in production may cause duplicate taps or other Gestures.
+     */
+    function resetMouseCanceller(): any;
+  }
+}
diff --git a/lib/utils/import-href.d.ts b/lib/utils/import-href.d.ts
new file mode 100644
index 0000000000..e65604d4c7
--- /dev/null
+++ b/lib/utils/import-href.d.ts
@@ -0,0 +1,25 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/import-href.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+
+  /**
+   * Convenience method for importing an HTML document imperatively.
+   *
+   * This method creates a new `<link rel="import">` element with
+   * the provided URL and appends it to the document to start loading.
+   * In the `onload` callback, the `import` property of the `link`
+   * element will contain the imported document contents.
+   */
+  function importHref(href: string, onload?: Function|null, onerror?: Function|null, optAsync?: boolean): HTMLLinkElement|null;
+}
diff --git a/lib/utils/mixin.d.ts b/lib/utils/mixin.d.ts
new file mode 100644
index 0000000000..77d61f5710
--- /dev/null
+++ b/lib/utils/mixin.d.ts
@@ -0,0 +1,22 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/mixin.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+
+  /**
+   * Wraps an ES6 class expression mixin such that the mixin is only applied
+   * if it has not already been applied its base argument. Also memoizes mixin
+   * applications.
+   */
+  function dedupingMixin(mixin: T|null): any;
+}
diff --git a/lib/utils/path.d.ts b/lib/utils/path.d.ts
new file mode 100644
index 0000000000..c2105fc727
--- /dev/null
+++ b/lib/utils/path.d.ts
@@ -0,0 +1,129 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/path.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+  namespace Path {
+
+
+    /**
+     * Returns true if the given string is a structured data path (has dots).
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.isPath('foo.bar.baz') // true
+     * Polymer.Path.isPath('foo')         // false
+     * ```
+     */
+    function isPath(path: string): boolean;
+
+
+    /**
+     * Returns the root property name for the given path.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.root('foo.bar.baz') // 'foo'
+     * Polymer.Path.root('foo')         // 'foo'
+     * ```
+     */
+    function root(path: string): string;
+
+
+    /**
+     * Given `base` is `foo.bar`, `foo` is an ancestor, `foo.bar` is not
+     * Returns true if the given path is an ancestor of the base path.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.isAncestor('foo.bar', 'foo')         // true
+     * Polymer.Path.isAncestor('foo.bar', 'foo.bar')     // false
+     * Polymer.Path.isAncestor('foo.bar', 'foo.bar.baz') // false
+     * ```
+     */
+    function isAncestor(base: string, path: string): boolean;
+
+
+    /**
+     * Given `base` is `foo.bar`, `foo.bar.baz` is an descendant
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.isDescendant('foo.bar', 'foo.bar.baz') // true
+     * Polymer.Path.isDescendant('foo.bar', 'foo.bar')     // false
+     * Polymer.Path.isDescendant('foo.bar', 'foo')         // false
+     * ```
+     */
+    function isDescendant(base: string, path: string): boolean;
+
+
+    /**
+     * Replaces a previous base path with a new base path, preserving the
+     * remainder of the path.
+     *
+     * User must ensure `path` has a prefix of `base`.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.translate('foo.bar', 'zot', 'foo.bar.baz') // 'zot.baz'
+     * ```
+     */
+    function translate(base: string, newBase: string, path: string): string;
+
+
+    /**
+     * Converts array-based paths to flattened path.  String-based paths
+     * are returned as-is.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.normalize(['foo.bar', 0, 'baz'])  // 'foo.bar.0.baz'
+     * Polymer.Path.normalize('foo.bar.0.baz')        // 'foo.bar.0.baz'
+     * ```
+     */
+    function normalize(path: string|Array<string|number>): string;
+
+
+    /**
+     * Splits a path into an array of property names. Accepts either arrays
+     * of path parts or strings.
+     *
+     * Example:
+     *
+     * ```
+     * Polymer.Path.split(['foo.bar', 0, 'baz'])  // ['foo', 'bar', '0', 'baz']
+     * Polymer.Path.split('foo.bar.0.baz')        // ['foo', 'bar', '0', 'baz']
+     * ```
+     */
+    function split(path: string|Array<string|number>): string[];
+
+
+    /**
+     * Reads a value from a path.  If any sub-property in the path is `undefined`,
+     * this method returns `undefined` (will never throw.
+     */
+    function get(root: Object|null, path: string|Array<string|number>, info?: Object|null): any;
+
+
+    /**
+     * Sets a value to a path.  If any sub-property in the path is `undefined`,
+     * this method will no-op.
+     */
+    function set(root: Object|null, path: string|Array<string|number>, value: any): string|undefined;
+  }
+}
diff --git a/lib/utils/render-status.d.ts b/lib/utils/render-status.d.ts
new file mode 100644
index 0000000000..d513bf7128
--- /dev/null
+++ b/lib/utils/render-status.d.ts
@@ -0,0 +1,42 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/render-status.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+  namespace RenderStatus {
+
+
+    /**
+     * Enqueues a callback which will be run before the next render, at
+     * `requestAnimationFrame` timing.
+     *
+     * This method is useful for enqueuing work that requires DOM measurement,
+     * since measurement may not be reliable in custom element callbacks before
+     * the first render, as well as for batching measurement tasks in general.
+     *
+     * Tasks in this queue may be flushed by calling `Polymer.RenderStatus.flush()`.
+     */
+    function beforeNextRender(context: any, callback: () => any, args: any[]|null): any;
+
+
+    /**
+     * Enqueues a callback which will be run after the next render, equivalent
+     * to one task (`setTimeout`) after the next `requestAnimationFrame`.
+     *
+     * This method is useful for tuning the first-render performance of an
+     * element or application by deferring non-critical work until after the
+     * first paint.  Typical non-render-critical work may include adding UI
+     * event listeners and aria attributes.
+     */
+    function afterNextRender(context: any, callback: () => any, args: any[]|null): any;
+  }
+}
diff --git a/lib/utils/resolve-url.d.ts b/lib/utils/resolve-url.d.ts
new file mode 100644
index 0000000000..f5fc4a6db2
--- /dev/null
+++ b/lib/utils/resolve-url.d.ts
@@ -0,0 +1,37 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/resolve-url.html
+ */
+
+/// <reference path="boot.d.ts" />
+
+declare namespace Polymer {
+
+  namespace ResolveUrl {
+
+
+    /**
+     * Resolves the given URL against the provided `baseUri'.
+     */
+    function resolveUrl(url: string, baseURI?: string|null): string;
+
+
+    /**
+     * Resolves any relative URL's in the given CSS text against the provided
+     * `ownerDocument`'s `baseURI`.
+     */
+    function resolveCss(cssText: string, baseURI: string): string;
+
+
+    /**
+     * Returns a path from a given `url`. The path includes the trailing
+     * `/` from the url.
+     */
+    function pathFromUrl(url: string): string;
+  }
+}
diff --git a/lib/utils/settings.d.ts b/lib/utils/settings.d.ts
new file mode 100644
index 0000000000..d14a38953c
--- /dev/null
+++ b/lib/utils/settings.d.ts
@@ -0,0 +1,34 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/settings.html
+ */
+
+/// <reference path="boot.d.ts" />
+/// <reference path="resolve-url.d.ts" />
+
+declare namespace Polymer {
+
+
+  /**
+   * Sets the global rootPath property used by `Polymer.ElementMixin` and
+   * available via `Polymer.rootPath`.
+   */
+  function setRootPath(path: string): any;
+
+
+  /**
+   * Sets the global sanitizeDOMValue available via `Polymer.sanitizeDOMValue`.
+   */
+  function setSanitizeDOMValue(newSanitizeDOMValue: ((p0: any, p1: string, p2: string, p3: Node|null) => any)|undefined): any;
+
+
+  /**
+   * Sets `passiveTouchGestures` globally for all elements using Polymer Gestures.
+   */
+  function setPassiveTouchGestures(usePassive: boolean): any;
+}
diff --git a/lib/utils/style-gather.d.ts b/lib/utils/style-gather.d.ts
new file mode 100644
index 0000000000..38fabd3e56
--- /dev/null
+++ b/lib/utils/style-gather.d.ts
@@ -0,0 +1,85 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/style-gather.html
+ */
+
+/// <reference path="resolve-url.d.ts" />
+
+declare namespace Polymer {
+
+  namespace StyleGather {
+
+
+    /**
+     * Returns a list of <style> elements in a space-separated list of `dom-module`s.
+     */
+    function stylesFromModules(moduleIds: string): any[]|null;
+
+
+    /**
+     * Returns a list of <style> elements in a given `dom-module`.
+     * Styles in a `dom-module` can come either from `<style>`s within the
+     * first `<template>`, or else from one or more
+     * `<link rel="import" type="css">` links outside the template.
+     */
+    function stylesFromModule(moduleId: string): any[]|null;
+
+
+    /**
+     * Returns the `<style>` elements within a given template.
+     */
+    function stylesFromTemplate(template: HTMLTemplateElement|null, baseURI: string): any[]|null;
+
+
+    /**
+     * Returns a list of <style> elements  from stylesheets loaded via `<link rel="import" type="css">` links within the specified `dom-module`.
+     */
+    function stylesFromModuleImports(moduleId: string): any[]|null;
+
+    function _stylesFromModuleImports(module: HTMLElement): any[]|null;
+
+
+    /**
+     * Returns CSS text of styles in a space-separated list of `dom-module`s.
+     * Note: This method is deprecated, use `stylesFromModules` instead.
+     */
+    function cssFromModules(moduleIds: string): string;
+
+
+    /**
+     * Returns CSS text of styles in a given `dom-module`.  CSS in a `dom-module`
+     * can come either from `<style>`s within the first `<template>`, or else
+     * from one or more `<link rel="import" type="css">` links outside the
+     * template.
+     *
+     * Any `<styles>` processed are removed from their original location.
+     * Note: This method is deprecated, use `styleFromModule` instead.
+     */
+    function cssFromModule(moduleId: string): string;
+
+
+    /**
+     * Returns CSS text of `<styles>` within a given template.
+     *
+     * Any `<styles>` processed are removed from their original location.
+     * Note: This method is deprecated, use `styleFromTemplate` instead.
+     */
+    function cssFromTemplate(template: HTMLTemplateElement|null, baseURI: string): string;
+
+
+    /**
+     * Returns CSS text from stylesheets loaded via `<link rel="import" type="css">`
+     * links within the specified `dom-module`.
+     *
+     * Note: This method is deprecated, use `stylesFromModuleImports` instead.
+     */
+    function cssFromModuleImports(moduleId: string): string;
+
+    function _cssFromModuleImports(module: HTMLElement): string;
+  }
+}
diff --git a/lib/utils/templatize.d.ts b/lib/utils/templatize.d.ts
new file mode 100644
index 0000000000..5f3186ed74
--- /dev/null
+++ b/lib/utils/templatize.d.ts
@@ -0,0 +1,149 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/templatize.html
+ */
+
+/// <reference path="boot.d.ts" />
+/// <reference path="../mixins/property-effects.d.ts" />
+/// <reference path="../mixins/mutable-data.d.ts" />
+
+declare class TemplateInstanceBase extends
+  Polymer.PropertyEffects(
+  Polymer.Element) {
+  _addEventListenerToNode(node: any, eventName: any, handler: any): any;
+
+  /**
+   * Overrides default property-effects implementation to intercept
+   * textContent bindings while children are "hidden" and cache in
+   * private storage for later retrieval.
+   */
+  _setUnmanagedPropertyToNode(node: any, prop: any, value: any): any;
+
+  /**
+   * Configure the given `props` by calling `_setPendingProperty`. Also
+   * sets any properties stored in `__hostProps`.
+   *
+   * @param props Object of property name-value pairs to set.
+   */
+  _configureProperties(props: Object|null): any;
+
+  /**
+   * Forwards a host property to this instance.  This method should be
+   * called on instances from the `options.forwardHostProp` callback
+   * to propagate changes of host properties to each instance.
+   *
+   * Note this method enqueues the change, which are flushed as a batch.
+   *
+   * @param prop Property or path name
+   * @param value Value of the property to forward
+   */
+  forwardHostProp(prop: string, value: any): any;
+
+  /**
+   * Shows or hides the template instance top level child elements. For
+   * text nodes, `textContent` is removed while "hidden" and replaced when
+   * "shown."
+   *
+   * @param hide Set to true to hide the children;
+   * set to false to show them.
+   */
+  _showHideChildren(hide: boolean): any;
+}
+
+declare class klass {
+}
+
+declare namespace templateInfo {
+
+  class templatizeTemplateClass {
+  }
+}
+
+declare namespace Polymer {
+
+  namespace Templatize {
+
+
+    /**
+     * Returns an anonymous `Polymer.PropertyEffects` class bound to the
+     * `<template>` provided.  Instancing the class will result in the
+     * template being stamped into document fragment stored as the instance's
+     * `root` property, after which it can be appended to the DOM.
+     *
+     * Templates may utilize all Polymer data-binding features as well as
+     * declarative event listeners.  Event listeners and inline computing
+     * functions in the template will be called on the host of the template.
+     *
+     * The constructor returned takes a single argument dictionary of initial
+     * property values to propagate into template bindings.  Additionally
+     * host properties can be forwarded in, and instance properties can be
+     * notified out by providing optional callbacks in the `options` dictionary.
+     *
+     * Valid configuration in `options` are as follows:
+     *
+     * - `forwardHostProp(property, value)`: Called when a property referenced
+     *   in the template changed on the template's host. As this library does
+     *   not retain references to templates instanced by the user, it is the
+     *   templatize owner's responsibility to forward host property changes into
+     *   user-stamped instances.  The `instance.forwardHostProp(property, value)`
+     *    method on the generated class should be called to forward host
+     *   properties into the template to prevent unnecessary property-changed
+     *   notifications. Any properties referenced in the template that are not
+     *   defined in `instanceProps` will be notified up to the template's host
+     *   automatically.
+     * - `instanceProps`: Dictionary of property names that will be added
+     *   to the instance by the templatize owner.  These properties shadow any
+     *   host properties, and changes within the template to these properties
+     *   will result in `notifyInstanceProp` being called.
+     * - `mutableData`: When `true`, the generated class will skip strict
+     *   dirty-checking for objects and arrays (always consider them to be
+     *   "dirty").
+     * - `notifyInstanceProp(instance, property, value)`: Called when
+     *   an instance property changes.  Users may choose to call `notifyPath`
+     *   on e.g. the owner to notify the change.
+     * - `parentModel`: When `true`, events handled by declarative event listeners
+     *   (`on-event="handler"`) will be decorated with a `model` property pointing
+     *   to the template instance that stamped it.  It will also be returned
+     *   from `instance.parentModel` in cases where template instance nesting
+     *   causes an inner model to shadow an outer model.
+     *
+     * Note that the class returned from `templatize` is generated only once
+     * for a given `<template>` using `options` from the first call for that
+     * template, and the cached class is returned for all subsequent calls to
+     * `templatize` for that template.  As such, `options` callbacks should not
+     * close over owner-specific properties since only the first `options` is
+     * used; rather, callbacks are called bound to the `owner`, and so context
+     * needed from the callbacks (such as references to `instances` stamped)
+     * should be stored on the `owner` such that they can be retrieved via `this`.
+     */
+    function templatize(template: HTMLTemplateElement, owner: Polymer_PropertyEffects, options?: Object|null): () => any;
+
+
+    /**
+     * Returns the template "model" associated with a given element, which
+     * serves as the binding scope for the template instance the element is
+     * contained in. A template model is an instance of
+     * `TemplateInstanceBase`, and should be used to manipulate data
+     * associated with this template instance.
+     *
+     * Example:
+     *
+     *   let model = modelForElement(el);
+     *   if (model.index < 10) {
+     *     model.set('item.checked', true);
+     *   }
+     */
+    function modelForElement(template: HTMLTemplateElement|null, node: Node|null): TemplateInstanceBase|null;
+  }
+}
+
+/**
+ * Subclass base class and add reference for this specific template
+ */
+declare class klass {
+}
diff --git a/lib/utils/unresolved.d.ts b/lib/utils/unresolved.d.ts
new file mode 100644
index 0000000000..a46e651d50
--- /dev/null
+++ b/lib/utils/unresolved.d.ts
@@ -0,0 +1,10 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/utils/unresolved.html
+ */
+
diff --git a/polymer-element.d.ts b/polymer-element.d.ts
new file mode 100644
index 0000000000..292ce9663d
--- /dev/null
+++ b/polymer-element.d.ts
@@ -0,0 +1,24 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   polymer-element.html
+ */
+
+/// <reference path="lib/mixins/element-mixin.d.ts" />
+
+declare namespace Polymer {
+
+  /**
+   * Base class that provides the core API for Polymer's meta-programming
+   * features including template stamping, data-binding, attribute deserialization,
+   * and property change observation.
+   */
+  class Element extends
+    Polymer.ElementMixin(
+    HTMLElement) {
+  }
+}
diff --git a/polymer.d.ts b/polymer.d.ts
new file mode 100644
index 0000000000..9aa4ecee1a
--- /dev/null
+++ b/polymer.d.ts
@@ -0,0 +1,20 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   polymer.html
+ */
+
+/// <reference path="lib/legacy/legacy-element-mixin.d.ts" />
+/// <reference path="lib/legacy/polymer-fn.d.ts" />
+/// <reference path="lib/legacy/templatizer-behavior.d.ts" />
+/// <reference path="lib/elements/dom-bind.d.ts" />
+/// <reference path="lib/elements/dom-repeat.d.ts" />
+/// <reference path="lib/elements/dom-if.d.ts" />
+/// <reference path="lib/elements/array-selector.d.ts" />
+/// <reference path="lib/elements/custom-style.d.ts" />
+/// <reference path="lib/legacy/mutable-data-behavior.d.ts" />
+