From 9dbc87284dfffbede467ae62165aa976021560d9 Mon Sep 17 00:00:00 2001
From: Tim van der Lippe <TimvdLippe@users.noreply.github.com>
Date: Tue, 18 Sep 2018 21:05:19 +0100
Subject: [PATCH] Update gen-closure-declarations to 0.5.0 (#5360)

* Update gen-closure-declarations to 0.5.0

This fixes the externs generation for our modules

* Generate closure types before publishing

* Actually remove closure-types.js from git

* Remove HTML Imports from webcomponents externs

* Add back externs/polymer-externs.js
---
 externs/.gitignore               |    1 +
 externs/closure-types.js         | 1415 ------------------------------
 externs/webcomponents-externs.js |   14 -
 package-lock.json                |   88 +-
 package.json                     |    4 +-
 5 files changed, 36 insertions(+), 1486 deletions(-)
 delete mode 100644 externs/closure-types.js

diff --git a/externs/.gitignore b/externs/.gitignore
index 33522114ba..6233b5b960 100644
--- a/externs/.gitignore
+++ b/externs/.gitignore
@@ -2,3 +2,4 @@
 # *
 !.gitignore
 !.npmignore
+closure-types.js
diff --git a/externs/closure-types.js b/externs/closure-types.js
deleted file mode 100644
index bc57da9291..0000000000
--- a/externs/closure-types.js
+++ /dev/null
@@ -1,1415 +0,0 @@
-/**
- * @fileoverview Generated typings for Polymer mixins
- * @externs
- *
- * @license
- * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
- * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
- * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
- * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
- * Code distributed by Google as part of the polymer project is also
- * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
- */
-/* eslint-disable */
-/**
-* @interface
-*/
-function Polymer_PropertiesChanged(){}
-/**
-* @param {string} property Name of the property
-* @param {boolean=} readOnly When true, no setter is created; the
-  protected `_setProperty` function must be used to set the property
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._createPropertyAccessor = function(property, readOnly){};
-/**
-* @param {string} property Name of the property
-*/
-Polymer_PropertiesChanged.prototype._addPropertyToAttributeMap = function(property){};
-/**
-* @param {string} property Name of the property
-* @param {boolean=} readOnly When true, no setter is created
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._definePropertyAccessor = function(property, readOnly){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype.ready = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._initializeProperties = function(){};
-/**
-* @param {Object} props Bag of property values that were overwritten
-  when creating property accessors.
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._initializeInstanceProperties = function(props){};
-/**
-* @param {string} property Name of the property
-* @param {*} value Value to set
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._setProperty = function(property, value){};
-/**
-* @param {string} property Name of property
-* @return {*}
-*/
-Polymer_PropertiesChanged.prototype._getProperty = function(property){};
-/**
-* @param {string} property Name of the property
-* @param {*} value Value to set
-* @param {boolean=} ext Not used here; affordance for closure
-* @return {boolean}
-*/
-Polymer_PropertiesChanged.prototype._setPendingProperty = function(property, value, ext){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._invalidateProperties = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._enableProperties = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._flushProperties = function(){};
-/**
-* @param {!Object} currentProps Bag of all current accessor values
-* @param {!Object} changedProps Bag of properties changed since the last
-  call to `_propertiesChanged`
-* @param {!Object} oldProps Bag of previous values for each property
-  in `changedProps`
-* @return {boolean}
-*/
-Polymer_PropertiesChanged.prototype._shouldPropertiesChange = function(currentProps, changedProps, oldProps){};
-/**
-* @param {!Object} currentProps Bag of all current accessor values
-* @param {!Object} changedProps Bag of properties changed since the last
-  call to `_propertiesChanged`
-* @param {!Object} oldProps Bag of previous values for each property
-  in `changedProps`
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
-/**
-* @param {string} property Property name
-* @param {*} value New property value
-* @param {*} old Previous property value
-* @return {boolean}
-*/
-Polymer_PropertiesChanged.prototype._shouldPropertyChange = function(property, value, old){};
-/**
-* @param {string} name Name of attribute that changed
-* @param {?string} old Old attribute value
-* @param {?string} value New attribute value
-* @param {?string} namespace Namespace of the attribute
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype.attributeChangedCallback = function(name, old, value, namespace){};
-/**
-* @param {string} attribute Name of attribute to deserialize.
-* @param {?string} value of the attribute.
-* @param {*=} type type to deserialize to, defaults to the value
-returned from `typeForProperty`
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._attributeToProperty = function(attribute, value, type){};
-/**
-* @param {string} property Property name to reflect.
-* @param {string=} attribute Attribute name to reflect to.
-* @param {*=} value Property value to refect.
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._propertyToAttribute = function(property, attribute, value){};
-/**
-* @param {Element} node Element to set attribute to.
-* @param {*} value Value to serialize.
-* @param {string} attribute Attribute name to serialize to.
-* @return {void}
-*/
-Polymer_PropertiesChanged.prototype._valueToNodeAttribute = function(node, value, attribute){};
-/**
-* @param {*} value Property value to serialize.
-* @return {(string | undefined)}
-*/
-Polymer_PropertiesChanged.prototype._serializeValue = function(value){};
-/**
-* @param {?string} value Value to deserialize.
-* @param {*=} type Type to deserialize the string to.
-* @return {*}
-*/
-Polymer_PropertiesChanged.prototype._deserializeValue = function(value, type){};
-/**
-* @param {!Object} props Object whose keys are names of accessors.
-* @return {void}
-*/
-Polymer_PropertiesChanged.createProperties = function(props){};
-/**
-* @param {string} property Property to convert
-* @return {string}
-*/
-Polymer_PropertiesChanged.attributeNameForProperty = function(property){};
-/**
-* @param {string} name Name of property
-*/
-Polymer_PropertiesChanged.typeForProperty = function(name){};
-/**
-* @interface
-* @extends {Polymer_PropertiesChanged}
-*/
-function Polymer_PropertyAccessors(){}
-/**
-* @param {string} property Name of the property
-* @param {boolean=} readOnly When true, no setter is created
-
-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.
-* @return {void}
-*/
-Polymer_PropertyAccessors.prototype._definePropertyAccessor = function(property, readOnly){};
-/**
-* @return {void}
-*/
-Polymer_PropertyAccessors.prototype._initializeProperties = function(){};
-/**
-* @param {*} value Property value to serialize.
-* @return {(string | undefined)}
-*/
-Polymer_PropertyAccessors.prototype._serializeValue = function(value){};
-/**
-* @param {?string} value Attribute value to deserialize.
-* @param {*=} type Type to deserialize the string to.
-* @return {*}
-*/
-Polymer_PropertyAccessors.prototype._deserializeValue = function(value, type){};
-/**
-* @param {Object} props Bag of property values that were overwritten
-  when creating property accessors.
-* @return {void}
-*/
-Polymer_PropertyAccessors.prototype._initializeProtoProperties = function(props){};
-/**
-* @param {string} attribute Name of attribute to ensure is set.
-* @param {string} value of the attribute.
-* @return {void}
-*/
-Polymer_PropertyAccessors.prototype._ensureAttribute = function(attribute, value){};
-/**
-* @param {string} property Property name
-* @return {boolean}
-*/
-Polymer_PropertyAccessors.prototype._hasAccessor = function(property){};
-/**
-* @param {string} prop Property name
-* @return {boolean}
-*/
-Polymer_PropertyAccessors.prototype._isPropertyPending = function(prop){};
-/**
-* @param {string} property Property to convert
-* @return {string}
-*/
-Polymer_PropertyAccessors.attributeNameForProperty = function(property){};
-/**
-* @return {void}
-*/
-Polymer_PropertyAccessors.createPropertiesForAttributes = function(){};
-/**
-* @interface
-*/
-function Polymer_TemplateStamp(){}
-/**
-* @param {!HTMLTemplateElement} template Template to stamp
-* @return {!StampedTemplate}
-*/
-Polymer_TemplateStamp.prototype._stampTemplate = function(template){};
-/**
-* @param {!Node} node Node to add listener on
-* @param {string} eventName Name of event
-* @param {string} methodName Name of method
-* @param {*=} context Context the method will be called on (defaults
-  to `node`)
-* @return {Function}
-*/
-Polymer_TemplateStamp.prototype._addMethodEventListenerToNode = function(node, eventName, methodName, context){};
-/**
-* @param {!Node} node Node to add event listener to
-* @param {string} eventName Name of event
-* @param {function (!Event): void} handler Listener function to add
-* @return {void}
-*/
-Polymer_TemplateStamp.prototype._addEventListenerToNode = function(node, eventName, handler){};
-/**
-* @param {!Node} node Node to remove event listener from
-* @param {string} eventName Name of event
-* @param {function (!Event): void} handler Listener function to remove
-* @return {void}
-*/
-Polymer_TemplateStamp.prototype._removeEventListenerFromNode = function(node, eventName, handler){};
-/**
-* @param {!HTMLTemplateElement} template Template to parse
-* @param {TemplateInfo=} outerTemplateInfo Template metadata from the outer
-  template, for parsing nested templates
-* @return {!TemplateInfo}
-*/
-Polymer_TemplateStamp._parseTemplate = function(template, outerTemplateInfo){};
-/**
-* @param {*} template
-* @param {*} templateInfo
-* @param {*} nodeInfo
-*/
-Polymer_TemplateStamp._parseTemplateContent = function(template, templateInfo, nodeInfo){};
-/**
-* @param {Node} node Node to parse
-* @param {!TemplateInfo} templateInfo Template metadata for current template
-* @param {!NodeInfo} nodeInfo Node metadata for current template.
-* @return {boolean}
-*/
-Polymer_TemplateStamp._parseTemplateNode = function(node, templateInfo, nodeInfo){};
-/**
-* @param {Node} root Root node whose `childNodes` will be parsed
-* @param {!TemplateInfo} templateInfo Template metadata for current template
-* @param {!NodeInfo} nodeInfo Node metadata for current template.
-* @return {void}
-*/
-Polymer_TemplateStamp._parseTemplateChildNodes = function(root, templateInfo, nodeInfo){};
-/**
-* @param {HTMLTemplateElement} node Node to parse (a <template>)
-* @param {TemplateInfo} outerTemplateInfo Template metadata for current template
-  that includes the template `node`
-* @param {!NodeInfo} nodeInfo Node metadata for current template.
-* @return {boolean}
-*/
-Polymer_TemplateStamp._parseTemplateNestedTemplate = function(node, outerTemplateInfo, nodeInfo){};
-/**
-* @param {Element} node Node to parse
-* @param {TemplateInfo} templateInfo Template metadata for current template
-* @param {NodeInfo} nodeInfo Node metadata for current template.
-* @return {boolean}
-*/
-Polymer_TemplateStamp._parseTemplateNodeAttributes = function(node, templateInfo, nodeInfo){};
-/**
-* @param {Element} node Node to parse
-* @param {!TemplateInfo} templateInfo Template metadata for current template
-* @param {!NodeInfo} nodeInfo Node metadata for current template.
-* @param {string} name Attribute name
-* @param {string} value Attribute value
-* @return {boolean}
-*/
-Polymer_TemplateStamp._parseTemplateNodeAttribute = function(node, templateInfo, nodeInfo, name, value){};
-/**
-* @param {HTMLTemplateElement} template Template to retrieve `content` for
-* @return {DocumentFragment}
-*/
-Polymer_TemplateStamp._contentForTemplate = function(template){};
-/**
-* @interface
-* @extends {Polymer_TemplateStamp}
-* @extends {Polymer_PropertyAccessors}
-*/
-function Polymer_PropertyEffects(){}
-/** @type {boolean} */
-Polymer_PropertyEffects.prototype.__dataClientsReady;
-
-/** @type {Array} */
-Polymer_PropertyEffects.prototype.__dataPendingClients;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__dataToNotify;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__dataLinkedPaths;
-
-/** @type {boolean} */
-Polymer_PropertyEffects.prototype.__dataHasPaths;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__dataCompoundStorage;
-
-/** @type {Polymer_PropertyEffects} */
-Polymer_PropertyEffects.prototype.__dataHost;
-
-/** @type {!Object} */
-Polymer_PropertyEffects.prototype.__dataTemp;
-
-/** @type {boolean} */
-Polymer_PropertyEffects.prototype.__dataClientsInitialized;
-
-/** @type {!Object} */
-Polymer_PropertyEffects.prototype.__data;
-
-/** @type {!Object} */
-Polymer_PropertyEffects.prototype.__dataPending;
-
-/** @type {!Object} */
-Polymer_PropertyEffects.prototype.__dataOld;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__computeEffects;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__reflectEffects;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__notifyEffects;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__propagateEffects;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__observeEffects;
-
-/** @type {Object} */
-Polymer_PropertyEffects.prototype.__readOnly;
-
-/** @type {!TemplateInfo} */
-Polymer_PropertyEffects.prototype.__templateInfo;
-
-/**
-* @override
-* @param {!HTMLTemplateElement} template Template to stamp
-* @return {!StampedTemplate}
-*/
-Polymer_PropertyEffects.prototype._stampTemplate = function(template){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype.ready = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._initializeProperties = function(){};
-/**
-* @override
-* @param {Object} props Properties to initialize on the instance
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._initializeInstanceProperties = function(props){};
-/**
-* @override
-* @param {string} property Name of the property
-* @param {*} value Value to set
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._setProperty = function(property, value){};
-/**
-* @override
-* @param {string} property Name of the property
-* @param {*} value Value to set
-* @param {boolean=} shouldNotify True if property should fire notification
-  event (applies only for `notify: true` properties)
-* @return {boolean}
-*/
-Polymer_PropertyEffects.prototype._setPendingProperty = function(property, value, shouldNotify){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._invalidateProperties = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._flushProperties = function(){};
-/**
-* @param {!Object} currentProps Bag of all current accessor values
-* @param {!Object} changedProps Bag of properties changed since the last
-  call to `_propertiesChanged`
-* @param {!Object} oldProps Bag of previous values for each property
-  in `changedProps`
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
-/**
-* @override
-* @param {Object} props Properties to initialize on the prototype
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._initializeProtoProperties = function(props){};
-/**
-* @param {string} property Property that should trigger the effect
-* @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
-* @param {Object=} effect Effect metadata object
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._addPropertyEffect = function(property, type, effect){};
-/**
-* @param {string} property Property the effect was associated with
-* @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
-* @param {Object=} effect Effect metadata object to remove
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._removePropertyEffect = function(property, type, effect){};
-/**
-* @param {string} property Property name
-* @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES
-* @return {boolean}
-*/
-Polymer_PropertyEffects.prototype._hasPropertyEffect = function(property, type){};
-/**
-* @param {string} property Property name
-* @return {boolean}
-*/
-Polymer_PropertyEffects.prototype._hasReadOnlyEffect = function(property){};
-/**
-* @param {string} property Property name
-* @return {boolean}
-*/
-Polymer_PropertyEffects.prototype._hasNotifyEffect = function(property){};
-/**
-* @param {string} property Property name
-* @return {boolean}
-*/
-Polymer_PropertyEffects.prototype._hasReflectEffect = function(property){};
-/**
-* @param {string} property Property name
-* @return {boolean}
-*/
-Polymer_PropertyEffects.prototype._hasComputedEffect = function(property){};
-/**
-* @param {(string | !Array.<(number | string)>)} path Path to set
-* @param {*} value Value to set
-* @param {boolean=} shouldNotify Set to true if this change should
- cause a property notification event dispatch
-* @param {boolean=} 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.
-* @return {boolean}
-*/
-Polymer_PropertyEffects.prototype._setPendingPropertyOrPath = function(path, value, shouldNotify, isPathNotification){};
-/**
-* @param {!Node} node The node to set a property on
-* @param {string} prop The property to set
-* @param {*} value The value to set
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._setUnmanagedPropertyToNode = function(node, prop, value){};
-/**
-* @param {Object} client PropertyEffects client to enqueue
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._enqueueClient = function(client){};
-/**
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._flushClients = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._readyClients = function(){};
-/**
-* @param {Object} 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 {boolean=} setReadOnly When true, any private values set in
-  `props` will be set. By default, `setProperties` will not set
-  `readOnly: true` root properties.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype.setProperties = function(props, setReadOnly){};
-/**
-* @param {Object} changedProps Bag of changed properties
-* @param {Object} oldProps Bag of previous values for changed properties
-* @param {boolean} hasPaths True with `props` contains one or more paths
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._propagatePropertyChanges = function(changedProps, oldProps, hasPaths){};
-/**
-* @param {(string | !Array.<(string | number)>)} to Target path to link.
-* @param {(string | !Array.<(string | number)>)} from Source path to link.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype.linkPaths = function(to, from){};
-/**
-* @param {(string | !Array.<(string | number)>)} path Target path to unlink.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype.unlinkPaths = function(path){};
-/**
-* @param {string} path Path that should be notified.
-* @param {Array} 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).
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype.notifySplices = function(path, splices){};
-/**
-* @param {(string | !Array.<(string | number)>)} 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 {Object=} root Root object from which the path is evaluated.
-* @return {*}
-*/
-Polymer_PropertyEffects.prototype.get = function(path, root){};
-/**
-* @param {(string | !Array.<(string | number)>)} 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 {Object=} root Root object from which the path is evaluated.
-  When specified, no notification will occur.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype.set = function(path, value, root){};
-/**
-* @param {(string | !Array.<(string | number)>)} path Path to array.
-* @param {...*} items Items to push onto array
-* @return {number}
-*/
-Polymer_PropertyEffects.prototype.push = function(path, items){};
-/**
-* @param {(string | !Array.<(string | number)>)} path Path to array.
-* @return {*}
-*/
-Polymer_PropertyEffects.prototype.pop = function(path){};
-/**
-* @param {(string | !Array.<(string | number)>)} path Path to array.
-* @param {number} start Index from which to start removing/inserting.
-* @param {number} deleteCount Number of items to remove.
-* @param {...*} items Items to insert into array.
-* @return {Array}
-*/
-Polymer_PropertyEffects.prototype.splice = function(path, start, deleteCount, items){};
-/**
-* @param {(string | !Array.<(string | number)>)} path Path to array.
-* @return {*}
-*/
-Polymer_PropertyEffects.prototype.shift = function(path){};
-/**
-* @param {(string | !Array.<(string | number)>)} path Path to array.
-* @param {...*} items Items to insert info array
-* @return {number}
-*/
-Polymer_PropertyEffects.prototype.unshift = function(path, items){};
-/**
-* @param {string} path Path that should be notified.
-* @param {*=} value Value at the path (optional).
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype.notifyPath = function(path, value){};
-/**
-* @param {string} property Property name
-* @param {boolean=} protectedSetter Creates a custom protected setter
-  when `true`.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._createReadOnlyProperty = function(property, protectedSetter){};
-/**
-* @param {string} property Property name
-* @param {(string | function (*, *))} method Function or name of observer method to call
-* @param {boolean=} dynamicFn Whether the method name should be included as
-  a dependency to the effect.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._createPropertyObserver = function(property, method, dynamicFn){};
-/**
-* @param {string} expression Method expression
-* @param {(boolean | Object)=} dynamicFn Boolean or object map indicating
-  whether method names should be included as a dependency to the effect.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._createMethodObserver = function(expression, dynamicFn){};
-/**
-* @param {string} property Property name
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._createNotifyingProperty = function(property){};
-/**
-* @param {string} property Property name
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._createReflectedProperty = function(property){};
-/**
-* @param {string} property Name of computed property to set
-* @param {string} expression Method expression
-* @param {(boolean | Object)=} dynamicFn Boolean or object map indicating
-  whether method names should be included as a dependency to the effect.
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._createComputedProperty = function(property, expression, dynamicFn){};
-/**
-* @param {!HTMLTemplateElement} template Template containing binding
-  bindings
-* @param {boolean=} 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.
-* @return {!TemplateInfo}
-*/
-Polymer_PropertyEffects.prototype._bindTemplate = function(template, instanceBinding){};
-/**
-* @param {!StampedTemplate} dom DocumentFragment previously returned
-  from `_stampTemplate` associated with the nodes to be removed
-* @return {void}
-*/
-Polymer_PropertyEffects.prototype._removeBoundDom = function(dom){};
-/**
-* @override
-* @param {Node} node Node to parse
-* @param {TemplateInfo} templateInfo Template metadata for current template
-* @param {NodeInfo} nodeInfo Node metadata for current template node
-* @return {boolean}
-*/
-Polymer_PropertyEffects._parseTemplateNode = function(node, templateInfo, nodeInfo){};
-/**
-* @override
-* @param {Node} node Node to parse
-* @param {TemplateInfo} templateInfo Template metadata for current template
-* @param {NodeInfo} nodeInfo Node metadata for current template node
-* @return {boolean}
-*/
-Polymer_PropertyEffects._parseTemplateNestedTemplate = function(node, templateInfo, nodeInfo){};
-/**
-* @override
-* @param {Element} node Node to parse
-* @param {TemplateInfo} templateInfo Template metadata for current template
-* @param {NodeInfo} nodeInfo Node metadata for current template node
-* @param {string} name Attribute name
-* @param {string} value Attribute value
-* @return {boolean}
-*/
-Polymer_PropertyEffects._parseTemplateNodeAttribute = function(node, templateInfo, nodeInfo, name, value){};
-/**
-* @param {string} property Property that should trigger the effect
-* @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
-* @param {Object=} effect Effect metadata object
-* @return {void}
-*/
-Polymer_PropertyEffects.addPropertyEffect = function(property, type, effect){};
-/**
-* @param {string} property Property name
-* @param {(string | function (*, *))} method Function or name of observer method to call
-* @param {boolean=} dynamicFn Whether the method name should be included as
-  a dependency to the effect.
-* @return {void}
-*/
-Polymer_PropertyEffects.createPropertyObserver = function(property, method, dynamicFn){};
-/**
-* @param {string} expression Method expression
-* @param {(boolean | Object)=} dynamicFn Boolean or object map indicating
-* @return {void}
-*/
-Polymer_PropertyEffects.createMethodObserver = function(expression, dynamicFn){};
-/**
-* @param {string} property Property name
-* @return {void}
-*/
-Polymer_PropertyEffects.createNotifyingProperty = function(property){};
-/**
-* @param {string} property Property name
-* @param {boolean=} protectedSetter Creates a custom protected setter
-  when `true`.
-* @return {void}
-*/
-Polymer_PropertyEffects.createReadOnlyProperty = function(property, protectedSetter){};
-/**
-* @param {string} property Property name
-* @return {void}
-*/
-Polymer_PropertyEffects.createReflectedProperty = function(property){};
-/**
-* @param {string} property Name of computed property to set
-* @param {string} expression Method expression
-* @param {(boolean | Object)=} dynamicFn Boolean or object map indicating whether
-  method names should be included as a dependency to the effect.
-* @return {void}
-*/
-Polymer_PropertyEffects.createComputedProperty = function(property, expression, dynamicFn){};
-/**
-* @param {!HTMLTemplateElement} template Template containing binding
-  bindings
-* @return {!TemplateInfo}
-*/
-Polymer_PropertyEffects.bindTemplate = function(template){};
-/**
-* @param {Object} templateInfo Template metadata to add effect to
-* @param {string} prop Property that should trigger the effect
-* @param {Object=} effect Effect metadata object
-* @return {void}
-*/
-Polymer_PropertyEffects._addTemplatePropertyEffect = function(templateInfo, prop, effect){};
-/**
-* @param {string} text Text to parse from attribute or textContent
-* @param {Object} templateInfo Current template metadata
-* @return {Array.<!BindingPart>}
-*/
-Polymer_PropertyEffects._parseBindings = function(text, templateInfo){};
-/**
-* @param {Element} inst Element that should be used as scope for
-  binding dependencies
-* @param {BindingPart} part Binding part metadata
-* @param {string} path Property/path that triggered this effect
-* @param {Object} props Bag of current property changes
-* @param {Object} oldProps Bag of previous values for changed properties
-* @param {boolean} hasPaths True with `props` contains one or more paths
-* @return {*}
-*/
-Polymer_PropertyEffects._evaluateBinding = function(inst, part, path, props, oldProps, hasPaths){};
-/**
-* @interface
-* @extends {Polymer_PropertiesChanged}
-*/
-function Polymer_PropertiesMixin(){}
-/**
-* @override
-* @return {void}
-*/
-Polymer_PropertiesMixin.prototype._initializeProperties = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesMixin.prototype.connectedCallback = function(){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesMixin.prototype.disconnectedCallback = function(){};
-/**
-* @param {string} name Name of property
-* @return {*}
-*/
-Polymer_PropertiesMixin.typeForProperty = function(name){};
-/**
-* @return {void}
-*/
-Polymer_PropertiesMixin.finalize = function(){};
-/**
-* @return {undefined}
-*/
-Polymer_PropertiesMixin._finalizeClass = function(){};
-/**
-* @interface
-* @extends {Polymer_PropertyEffects}
-* @extends {Polymer_PropertiesMixin}
-*/
-function Polymer_ElementMixin(){}
-/** @type {HTMLTemplateElement} */
-Polymer_ElementMixin.prototype._template;
-
-/** @type {string} */
-Polymer_ElementMixin.prototype._importPath;
-
-/** @type {string} */
-Polymer_ElementMixin.prototype.rootPath;
-
-/** @type {string} */
-Polymer_ElementMixin.prototype.importPath;
-
-/** @type {(StampedTemplate | HTMLElement | ShadowRoot)} */
-Polymer_ElementMixin.prototype.root;
-
-/** @type {!Object.<string, !Element>} */
-Polymer_ElementMixin.prototype.$;
-
-/**
-* @override
-* @return {void}
-*/
-Polymer_ElementMixin.prototype.ready = function(){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_ElementMixin.prototype._initializeProperties = function(){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_ElementMixin.prototype._readyClients = function(){};
-/**
-* @return {void}
-*/
-Polymer_ElementMixin.prototype.connectedCallback = function(){};
-/**
-* @param {StampedTemplate} dom to attach to the element.
-* @return {ShadowRoot}
-*/
-Polymer_ElementMixin.prototype._attachDom = function(dom){};
-/**
-* @param {Object=} properties Bag of custom property key/values to
-  apply to this element.
-* @return {void}
-*/
-Polymer_ElementMixin.prototype.updateStyles = function(properties){};
-/**
-* @param {string} url URL to resolve.
-* @param {string=} base Optional base URL to resolve against, defaults
-to the element's `importPath`
-* @return {string}
-*/
-Polymer_ElementMixin.prototype.resolveUrl = function(url, base){};
-/**
-* @override
-*/
-Polymer_ElementMixin._parseTemplateContent = function(template, templateInfo, nodeInfo){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_ElementMixin.createProperties = function(props){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_ElementMixin._finalizeClass = function(){};
-/**
-* @param {Object} observers Array of observer descriptors for
-  this class
-* @param {Object} dynamicFns Object containing keys for any properties
-  that are functions and should trigger the effect when the function
-  reference is changed
-* @return {void}
-*/
-Polymer_ElementMixin.createObservers = function(observers, dynamicFns){};
-/**
-* @param {string} cssText Text containing styling to process
-* @param {string} baseURI Base URI to rebase CSS paths against
-* @return {string}
-*/
-Polymer_ElementMixin._processStyleText = function(cssText, baseURI){};
-/**
-* @param {string} is Tag name (or type extension name) for this element
-* @return {void}
-*/
-Polymer_ElementMixin._finalizeTemplate = function(is){};
-/**
-* @interface
-*/
-function Polymer_GestureEventListeners(){}
-/**
-* @param {!Node} node Node to add event listener to
-* @param {string} eventName Name of event
-* @param {function (!Event): void} handler Listener function to add
-* @return {void}
-*/
-Polymer_GestureEventListeners.prototype._addEventListenerToNode = function(node, eventName, handler){};
-/**
-* @param {!Node} node Node to remove event listener from
-* @param {string} eventName Name of event
-* @param {function (!Event): void} handler Listener function to remove
-* @return {void}
-*/
-Polymer_GestureEventListeners.prototype._removeEventListenerFromNode = function(node, eventName, handler){};
-/**
-* @interface
-* @extends {Polymer_PropertyAccessors}
-*/
-function Polymer_DirMixin(){}
-/** @type {boolean} */
-Polymer_DirMixin.prototype.__autoDirOptOut;
-
-/**
-* @return {void}
-*/
-Polymer_DirMixin.prototype.ready = function(){};
-/**
-* @return {void}
-*/
-Polymer_DirMixin.prototype.connectedCallback = function(){};
-/**
-* @return {void}
-*/
-Polymer_DirMixin.prototype.disconnectedCallback = function(){};
-/**
-* @override
-*/
-Polymer_DirMixin._processStyleText = function(cssText, baseURI){};
-/**
-* @param {string} text CSS text to replace DIR
-* @return {string}
-*/
-Polymer_DirMixin._replaceDirInCssText = function(text){};
-/**
-* @interface
-* @extends {Polymer_ElementMixin}
-* @extends {Polymer_GestureEventListeners}
-*/
-function Polymer_LegacyElementMixin(){}
-/** @type {boolean} */
-Polymer_LegacyElementMixin.prototype.isAttached;
-
-/** @type {WeakMap.<!Element, !Object.<string, !Function>>} */
-Polymer_LegacyElementMixin.prototype.__boundListeners;
-
-/** @type {Object.<string, Function>} */
-Polymer_LegacyElementMixin.prototype._debouncers;
-
-/**
-* @override
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.ready = function(){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._initializeProperties = function(){};
-/**
-* @override
-* @param {string} name Name of attribute.
-* @param {?string} old Old value of attribute.
-* @param {?string} value Current value of attribute.
-* @param {?string} namespace Namespace of the attribute
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.attributeChangedCallback = function(name, old, value, namespace){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.connectedCallback = function(){};
-/**
-* @override
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.disconnectedCallback = function(){};
-/**
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.created = function(){};
-/**
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.attached = function(){};
-/**
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.detached = function(){};
-/**
-* @param {string} name Name of attribute.
-* @param {?string} old Old value of attribute.
-* @param {?string} value Current value of attribute.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.attributeChanged = function(name, old, value){};
-/**
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._registered = function(){};
-/**
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._ensureAttributes = function(){};
-/**
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._applyListeners = function(){};
-/**
-* @param {*} value Value to deserialize
-* @return {(string | undefined)}
-*/
-Polymer_LegacyElementMixin.prototype.serialize = function(value){};
-/**
-* @param {string} value String to deserialize
-* @param {*} type Type to deserialize the string to
-* @return {*}
-*/
-Polymer_LegacyElementMixin.prototype.deserialize = function(value, type){};
-/**
-* @param {string} property Property name to reflect.
-* @param {string=} attribute Attribute name to reflect.
-* @param {*=} value Property value to reflect.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.reflectPropertyToAttribute = function(property, attribute, value){};
-/**
-* @param {*} value Value to serialize.
-* @param {string} attribute Attribute name to serialize to.
-* @param {Element} node Element to set attribute to.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.serializeValueToAttribute = function(value, attribute, node){};
-/**
-* @param {Object} prototype Target object to copy properties to.
-* @param {Object} api Source object to copy properties from.
-* @return {Object}
-*/
-Polymer_LegacyElementMixin.prototype.extend = function(prototype, api){};
-/**
-* @param {!Object} target Target object to copy properties to.
-* @param {!Object} source Source object to copy properties from.
-* @return {!Object}
-*/
-Polymer_LegacyElementMixin.prototype.mixin = function(target, source){};
-/**
-* @param {Object} object The object on which to set the prototype.
-* @param {Object} prototype The prototype that will be set on the given
-`object`.
-* @return {Object}
-*/
-Polymer_LegacyElementMixin.prototype.chainObject = function(object, prototype){};
-/**
-* @param {HTMLTemplateElement} template HTML template element to instance.
-* @return {!DocumentFragment}
-*/
-Polymer_LegacyElementMixin.prototype.instanceTemplate = function(template){};
-/**
-* @param {string} type Name of event type.
-* @param {*=} detail Detail value containing event-specific
-  payload.
-* @param {{bubbles: (boolean | undefined), cancelable: (boolean | undefined), composed: (boolean | undefined)}=} 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`).
-* @return {!Event}
-*/
-Polymer_LegacyElementMixin.prototype.fire = function(type, detail, options){};
-/**
-* @param {Element} node Element to add event listener to.
-* @param {string} eventName Name of event to listen for.
-* @param {string} methodName Name of handler method on `this` to call.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.listen = function(node, eventName, methodName){};
-/**
-* @param {Element} node Element to remove event listener from.
-* @param {string} eventName Name of event to stop listening to.
-* @param {string} methodName Name of handler method on `this` to not call
-       anymore.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.unlisten = function(node, eventName, methodName){};
-/**
-* @param {string=} direction Direction to allow scrolling
-Defaults to `all`.
-* @param {Element=} node Element to apply scroll direction setting.
-Defaults to `this`.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.setScrollDirection = function(direction, node){};
-/**
-* @param {string} slctr Selector to run on this local DOM scope
-* @return {Element}
-*/
-Polymer_LegacyElementMixin.prototype.$$ = function(slctr){};
-/**
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.distributeContent = function(){};
-/**
-* @return {!Array.<!Node>}
-*/
-Polymer_LegacyElementMixin.prototype.getEffectiveChildNodes = function(){};
-/**
-* @param {string} selector Selector to run.
-* @return {!Array.<!Node>}
-*/
-Polymer_LegacyElementMixin.prototype.queryDistributedElements = function(selector){};
-/**
-* @return {!Array.<!Node>}
-*/
-Polymer_LegacyElementMixin.prototype.getEffectiveChildren = function(){};
-/**
-* @return {string}
-*/
-Polymer_LegacyElementMixin.prototype.getEffectiveTextContent = function(){};
-/**
-* @param {string} selector Selector to run.
-* @return {Node}
-*/
-Polymer_LegacyElementMixin.prototype.queryEffectiveChildren = function(selector){};
-/**
-* @param {string} selector Selector to run.
-* @return {!Array.<!Node>}
-*/
-Polymer_LegacyElementMixin.prototype.queryAllEffectiveChildren = function(selector){};
-/**
-* @param {string=} slctr CSS selector to choose the desired
-  `<slot>`.  Defaults to `content`.
-* @return {!Array.<!Node>}
-*/
-Polymer_LegacyElementMixin.prototype.getContentChildNodes = function(slctr){};
-/**
-* @param {string=} slctr CSS selector to choose the desired
-  `<content>`.  Defaults to `content`.
-* @return {!Array.<!HTMLElement>}
-*/
-Polymer_LegacyElementMixin.prototype.getContentChildren = function(slctr){};
-/**
-* @param {?Node} node The element to be checked.
-* @return {boolean}
-*/
-Polymer_LegacyElementMixin.prototype.isLightDescendant = function(node){};
-/**
-* @param {!Element} node The element to be checked.
-* @return {boolean}
-*/
-Polymer_LegacyElementMixin.prototype.isLocalDescendant = function(node){};
-/**
-* @param {*} container Unused
-* @param {*} shouldObserve Unused
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.scopeSubtree = function(container, shouldObserve){};
-/**
-* @param {string} property The css property name.
-* @return {string}
-*/
-Polymer_LegacyElementMixin.prototype.getComputedStyleValue = function(property){};
-/**
-* @param {string} jobName String to identify the debounce job.
-* @param {function (): void} callback Function that is called (with `this`
-  context) when the wait time elapses.
-* @param {number=} wait Optional wait time in milliseconds (ms) after the
-  last signal that must elapse before invoking `callback`
-* @return {!Object}
-*/
-Polymer_LegacyElementMixin.prototype.debounce = function(jobName, callback, wait){};
-/**
-* @param {string} jobName The name of the debouncer started with `debounce`
-* @return {boolean}
-*/
-Polymer_LegacyElementMixin.prototype.isDebouncerActive = function(jobName){};
-/**
-* @param {string} jobName The name of the debouncer started with `debounce`
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.flushDebouncer = function(jobName){};
-/**
-* @param {string} jobName The name of the debouncer started with `debounce`
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.cancelDebouncer = function(jobName){};
-/**
-* @param {!Function} callback The callback function to run, bound to `this`.
-* @param {number=} waitTime Time to wait before calling the
-  `callback`.  If unspecified or 0, the callback will be run at microtask
-  timing (before paint).
-* @return {number}
-*/
-Polymer_LegacyElementMixin.prototype.async = function(callback, waitTime){};
-/**
-* @param {number} handle Handle returned from original `async` call to
-  cancel.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.cancelAsync = function(handle){};
-/**
-* @param {string} tag HTML element tag to create.
-* @param {Object=} props Object of properties to configure on the
-   instance.
-* @return {!Element}
-*/
-Polymer_LegacyElementMixin.prototype.create = function(tag, props){};
-/**
-* @param {string} href URL to document to load.
-* @param {?function (!Event): void=} onload Callback to notify when an import successfully
-  loaded.
-* @param {?function (!ErrorEvent): void=} onerror Callback to notify when an import
-  unsuccessfully loaded.
-* @param {boolean=} optAsync True if the import should be loaded `async`.
-  Defaults to `false`.
-* @return {!HTMLLinkElement}
-*/
-Polymer_LegacyElementMixin.prototype.importHref = function(href, onload, onerror, optAsync){};
-/**
-* @param {string} selector Selector to test.
-* @param {!Element=} node Element to test the selector against.
-* @return {boolean}
-*/
-Polymer_LegacyElementMixin.prototype.elementMatches = function(selector, node){};
-/**
-* @param {string} name HTML attribute name
-* @param {boolean=} bool Boolean to force the attribute on or off.
-   When unspecified, the state of the attribute will be reversed.
-* @param {Element=} node Node to target.  Defaults to `this`.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.toggleAttribute = function(name, bool, node){};
-/**
-* @param {string} name CSS class name
-* @param {boolean=} bool Boolean to force the class on or off.
-   When unspecified, the state of the class will be reversed.
-* @param {Element=} node Node to target.  Defaults to `this`.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.toggleClass = function(name, bool, node){};
-/**
-* @param {string} transformText Transform setting.
-* @param {Element=} node Element to apply the transform to.
-Defaults to `this`
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.transform = function(transformText, node){};
-/**
-* @param {number} x X offset.
-* @param {number} y Y offset.
-* @param {number} z Z offset.
-* @param {Element=} node Element to apply the transform to.
-Defaults to `this`.
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype.translate3d = function(x, y, z, node){};
-/**
-* @param {(string | !Array.<(number | string)>)} arrayOrPath Path to array from which to remove the item
-  (or the array itself).
-* @param {*} item Item to remove.
-* @return {Array}
-*/
-Polymer_LegacyElementMixin.prototype.arrayDelete = function(arrayOrPath, item){};
-/**
-* @param {string} level One of 'log', 'warn', 'error'
-* @param {Array} args Array of strings or objects to log
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._logger = function(level, args){};
-/**
-* @param {...*} args Array of strings or objects to log
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._log = function(args){};
-/**
-* @param {...*} args Array of strings or objects to log
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._warn = function(args){};
-/**
-* @param {...*} args Array of strings or objects to log
-* @return {void}
-*/
-Polymer_LegacyElementMixin.prototype._error = function(args){};
-/**
-* @param {string} methodName Method name to associate with message
-* @param {...*} args Array of strings or objects to log
-* @return {Array}
-*/
-Polymer_LegacyElementMixin.prototype._logf = function(methodName, args){};
-/**
-* @interface
-*/
-function Polymer_MutableData(){}
-/**
-* @param {string} property Property name
-* @param {*} value New property value
-* @param {*} old Previous property value
-* @return {boolean}
-*/
-Polymer_MutableData.prototype._shouldPropertyChange = function(property, value, old){};
-/**
-* @interface
-*/
-function Polymer_OptionalMutableData(){}
-/** @type {boolean} */
-Polymer_OptionalMutableData.prototype.mutableData;
-
-/**
-* @param {string} property Property name
-* @param {*} value New property value
-* @param {*} old Previous property value
-* @return {boolean}
-*/
-Polymer_OptionalMutableData.prototype._shouldPropertyChange = function(property, value, old){};
-/**
-* @interface
-* @extends {Polymer_ElementMixin}
-*/
-function Polymer_ArraySelectorMixin(){}
-/** @type {Array} */
-Polymer_ArraySelectorMixin.prototype.items;
-
-/** @type {boolean} */
-Polymer_ArraySelectorMixin.prototype.multi;
-
-/** @type {?(Object | Array.<!Object>)} */
-Polymer_ArraySelectorMixin.prototype.selected;
-
-/** @type {?Object} */
-Polymer_ArraySelectorMixin.prototype.selectedItem;
-
-/** @type {boolean} */
-Polymer_ArraySelectorMixin.prototype.toggle;
-
-/**
-* @return {void}
-*/
-Polymer_ArraySelectorMixin.prototype.clearSelection = function(){};
-/**
-* @param {*} item Item from `items` array to test
-* @return {boolean}
-*/
-Polymer_ArraySelectorMixin.prototype.isSelected = function(item){};
-/**
-* @param {number} idx Index from `items` array to test
-* @return {boolean}
-*/
-Polymer_ArraySelectorMixin.prototype.isIndexSelected = function(idx){};
-/**
-* @param {*} item Item from `items` array to deselect
-* @return {void}
-*/
-Polymer_ArraySelectorMixin.prototype.deselect = function(item){};
-/**
-* @param {number} idx Index from `items` array to deselect
-* @return {void}
-*/
-Polymer_ArraySelectorMixin.prototype.deselectIndex = function(idx){};
-/**
-* @param {*} item Item from `items` array to select
-* @return {void}
-*/
-Polymer_ArraySelectorMixin.prototype.select = function(item){};
-/**
-* @param {number} idx Index from `items` array to select
-* @return {void}
-*/
-Polymer_ArraySelectorMixin.prototype.selectIndex = function(idx){};
-/**
-* @interface
-* @extends {Polymer_PropertyEffects}
-*/
-function Polymer_StrictBindingParser(){}
-/**
-* @param {string} text Text to parse from attribute or textContent
-* @param {Object} templateInfo Current template metadata
-* @return {Array.<!BindingPart>}
-*/
-Polymer_StrictBindingParser._parseBindings = function(text, templateInfo){};
-/**
-* @interface
-* @extends {Polymer_ElementMixin}
-*/
-function Polymer_DisableUpgradeMixin(){}
-/**
-* @override
-*/
-Polymer_DisableUpgradeMixin.prototype._initializeProperties = function(){};
-/**
-* @override
-*/
-Polymer_DisableUpgradeMixin.prototype._enableProperties = function(){};
-/**
-* @override
-*/
-Polymer_DisableUpgradeMixin.prototype.attributeChangedCallback = function(name, old, value){};
-/**
-* @override
-*/
-Polymer_DisableUpgradeMixin.prototype.connectedCallback = function(){};
-/**
-* @override
-*/
-Polymer_DisableUpgradeMixin.prototype.disconnectedCallback = function(){};
diff --git a/externs/webcomponents-externs.js b/externs/webcomponents-externs.js
index 8bcf4cede5..4a1987d54d 100644
--- a/externs/webcomponents-externs.js
+++ b/externs/webcomponents-externs.js
@@ -12,20 +12,6 @@
  */
 /* eslint-disable */
 
-let HTMLImports = {
-  /**
-   * @param {function()} callback
-   */
-  whenReady(callback){},
-  /**
-   * @param {Element} element
-   * @returns {Document} document
-   */
-  importForElement(element){}
-};
-
-window.HTMLImports = HTMLImports;
-
 let ShadyDOM = {
   inUse: false,
   flush(){},
diff --git a/package-lock.json b/package-lock.json
index 6dd8408ecf..7e1d7c761f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1028,13 +1028,13 @@
       "dev": true
     },
     "@polymer/gen-closure-declarations": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/@polymer/gen-closure-declarations/-/gen-closure-declarations-0.4.0.tgz",
-      "integrity": "sha512-gRDYxL/2nko1dJDIS+l+nc7BBzIz4x5LF+X+fskXcoiH+2A4PdCBeQXbCSpq9Dne5iig6MIr7GaK+Z3Y+5STCA==",
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@polymer/gen-closure-declarations/-/gen-closure-declarations-0.5.0.tgz",
+      "integrity": "sha512-wZiwqhgKZcOzsraHzAZfdUs7FCszjG0lvMJ7GuDn6Wa77c7naQT8tx5KWtnGm5WC9WRc/XYg+fhqIjI+RVZJqg==",
       "dev": true,
       "requires": {
-        "escodegen": "^1.9.0",
-        "polymer-analyzer": "^2.3.0"
+        "escodegen": "^1.11.0",
+        "polymer-analyzer": "^3.1.2"
       }
     },
     "@polymer/gen-typescript-declarations": {
@@ -1541,21 +1541,6 @@
       "integrity": "sha1-uZny2fe0PKvgoaLzm8IDvH3K2p0=",
       "dev": true
     },
-    "@types/escodegen": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/@types/escodegen/-/escodegen-0.0.2.tgz",
-      "integrity": "sha1-fOpBqyQukQ6xD2WuGK66RZ1ms18=",
-      "dev": true
-    },
-    "@types/estraverse": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/@types/estraverse/-/estraverse-0.0.6.tgz",
-      "integrity": "sha1-Zp9833KreX5hJfjQD+0z1M8wwiE=",
-      "dev": true,
-      "requires": {
-        "@types/estree": "*"
-      }
-    },
     "@types/estree": {
       "version": "0.0.37",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.37.tgz",
@@ -7556,55 +7541,48 @@
       }
     },
     "polymer-analyzer": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/polymer-analyzer/-/polymer-analyzer-2.7.0.tgz",
-      "integrity": "sha512-yD5FYQ8thX/2vHTaEgTtCs/NSG3ko4VlEb0IjM/PFsu03lHNHnpadC1NGwKyvI9vOjcFhnw4mDEVW0lbxLo8Eg==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/polymer-analyzer/-/polymer-analyzer-3.1.2.tgz",
+      "integrity": "sha512-qAGdrrI9fknJurrMMG/vx4CioOdxr0WeQB0CNcB7jZhIuophJn5igqXti9JwTLVBAEIB17DJnsce5A4xFQDryQ==",
       "dev": true,
       "requires": {
+        "@babel/generator": "^7.0.0-beta.42",
+        "@babel/traverse": "^7.0.0-beta.42",
+        "@babel/types": "^7.0.0-beta.42",
+        "@types/babel-generator": "^6.25.1",
+        "@types/babel-traverse": "^6.25.2",
+        "@types/babel-types": "^6.25.1",
+        "@types/babylon": "^6.16.2",
         "@types/chai-subset": "^1.3.0",
         "@types/chalk": "^0.4.30",
         "@types/clone": "^0.1.30",
         "@types/cssbeautify": "^0.3.1",
         "@types/doctrine": "^0.0.1",
-        "@types/escodegen": "^0.0.2",
-        "@types/estraverse": "^0.0.6",
-        "@types/estree": "^0.0.37",
-        "@types/node": "^6.0.0",
+        "@types/is-windows": "^0.2.0",
+        "@types/minimatch": "^3.0.1",
         "@types/parse5": "^2.2.34",
+        "@types/path-is-inside": "^1.0.0",
+        "@types/resolve": "0.0.6",
+        "@types/whatwg-url": "^6.4.0",
+        "babylon": "^7.0.0-beta.42",
+        "cancel-token": "^0.1.1",
         "chalk": "^1.1.3",
         "clone": "^2.0.0",
         "cssbeautify": "^0.3.1",
-        "doctrine": "^2.0.0",
-        "dom5": "^2.1.0",
-        "escodegen": "^1.7.0",
-        "espree": "^3.1.7",
-        "estraverse": "^4.2.0",
+        "doctrine": "^2.0.2",
+        "dom5": "^3.0.0",
+        "indent": "0.0.2",
+        "is-windows": "^1.0.2",
         "jsonschema": "^1.1.0",
-        "parse5": "^2.2.1",
+        "minimatch": "^3.0.4",
+        "parse5": "^4.0.0",
+        "path-is-inside": "^1.0.2",
+        "resolve": "^1.5.0",
         "shady-css-parser": "^0.1.0",
         "stable": "^0.1.6",
-        "strip-indent": "^2.0.0"
-      },
-      "dependencies": {
-        "dom5": {
-          "version": "2.3.0",
-          "resolved": "https://registry.npmjs.org/dom5/-/dom5-2.3.0.tgz",
-          "integrity": "sha1-+CBJdb0NrLvltYqKk//B/tD/zSo=",
-          "dev": true,
-          "requires": {
-            "@types/clone": "^0.1.29",
-            "@types/node": "^6.0.0",
-            "@types/parse5": "^2.2.32",
-            "clone": "^2.1.0",
-            "parse5": "^2.2.2"
-          }
-        },
-        "parse5": {
-          "version": "2.2.3",
-          "resolved": "https://registry.npmjs.org/parse5/-/parse5-2.2.3.tgz",
-          "integrity": "sha1-DE/EHBAAxea5PUiwP4CDg3g06fY=",
-          "dev": true
-        }
+        "strip-indent": "^2.0.0",
+        "vscode-uri": "^1.0.1",
+        "whatwg-url": "^6.4.0"
       }
     },
     "polymer-build": {
diff --git a/package.json b/package.json
index 595a700993..81667e383d 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
     "test": "test"
   },
   "devDependencies": {
-    "@polymer/gen-closure-declarations": "^0.4.0",
+    "@polymer/gen-closure-declarations": "^0.5.0",
     "@polymer/gen-typescript-declarations": "^1.5.0",
     "@polymer/iron-component-page": "^3.0.0-pre.12",
     "@polymer/test-fixture": "^3.0.0-pre.12",
@@ -41,7 +41,7 @@
     "test": "npm run lint && polymer test --npm --module-resolution=node",
     "serve": "polymer serve --npm --module-resolution=node",
     "lint": "gulp lint",
-    "generate-types": "gen-typescript-declarations --outDir . --deleteExisting --verify",
+    "generate-types": "gen-typescript-declarations --outDir . --deleteExisting --verify && gulp generate-externs",
     "regen-package-lock": "rm -rf node_modules package-lock.json; npm install",
     "prepare": "npm run generate-types"
   },