diff --git a/externs/closure-types.js b/externs/closure-types.js
index 57b3925f25..f5793e1753 100644
--- a/externs/closure-types.js
+++ b/externs/closure-types.js
@@ -17,94 +17,126 @@
 /**
 * @interface
 */
-function Polymer_PropertyAccessors(){}
-/** @type {boolean} */
-Polymer_PropertyAccessors.prototype.__serializing;
-
-/** @type {number} */
-Polymer_PropertyAccessors.prototype.__dataCounter;
-
-/** @type {boolean} */
-Polymer_PropertyAccessors.prototype.__dataEnabled;
-
-/** @type {boolean} */
-Polymer_PropertyAccessors.prototype.__dataReady;
-
-/** @type {boolean} */
-Polymer_PropertyAccessors.prototype.__dataInvalid;
-
-/** @type {!Object} */
-Polymer_PropertyAccessors.prototype.__data;
-
-/** @type {Object} */
-Polymer_PropertyAccessors.prototype.__dataPending;
-
-/** @type {Object} */
-Polymer_PropertyAccessors.prototype.__dataOld;
-
-/** @type {Object} */
-Polymer_PropertyAccessors.prototype.__dataProto;
-
-/** @type {Object} */
-Polymer_PropertyAccessors.prototype.__dataHasAccessor;
-
-/** @type {Object} */
-Polymer_PropertyAccessors.prototype.__dataInstanceProps;
-
+function Polymer_PropertiesChanged(){}
 /**
-* @param {string} name Name of attribute that changed
-* @param {?string} old Old attribute value
-* @param {?string} value New attribute value
+* @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
 */
-Polymer_PropertyAccessors.prototype.attributeChangedCallback = function(name, old, value){};
+Polymer_PropertiesChanged.prototype._createPropertyAccessor = function(property, readOnly){};
+/**
+* @param {string} property Name of the property
+* @param {boolean=} readOnly When true, no setter is created
+*/
+Polymer_PropertiesChanged.prototype._generatePropertyAccessor = function(property, readOnly){};
 /**
 * @return {undefined}
 */
-Polymer_PropertyAccessors.prototype._initializeProperties = function(){};
+Polymer_PropertiesChanged.prototype.ready = function(){};
 /**
-* @param {Object} props Bag of property values that were overwritten
-  when creating property accessors.
+* @return {undefined}
 */
-Polymer_PropertyAccessors.prototype._initializeProtoProperties = function(props){};
+Polymer_PropertiesChanged.prototype._initializeProperties = function(){};
 /**
 * @param {Object} props Bag of property values that were overwritten
   when creating property accessors.
 */
-Polymer_PropertyAccessors.prototype._initializeInstanceProperties = function(props){};
+Polymer_PropertiesChanged.prototype._initializeInstanceProperties = function(props){};
 /**
-* @param {string} attribute Name of attribute to ensure is set.
-* @param {string} value of the attribute.
+* @param {string} property Name of the property
+* @param {*} value Value to set
 */
-Polymer_PropertyAccessors.prototype._ensureAttribute = function(attribute, value){};
+Polymer_PropertiesChanged.prototype._setProperty = function(property, value){};
 /**
-* @param {string} attribute Name of attribute to deserialize.
-* @param {?string} value of the attribute.
-* @param {*=} type type to deserialize to.
+* @param {string} property Name of property
+* @return {*}
 */
-Polymer_PropertyAccessors.prototype._attributeToProperty = function(attribute, value, type){};
+Polymer_PropertiesChanged.prototype._getProperty = function(property){};
 /**
-* @param {string} property Property name to reflect.
-* @param {string=} attribute Attribute name to reflect.
-* @param {*=} value Property value to refect.
+* @param {string} property Name of the property
+* @param {*} value Value to set
+* @return {boolean}
 */
-Polymer_PropertyAccessors.prototype._propertyToAttribute = function(property, attribute, value){};
+Polymer_PropertiesChanged.prototype._setPendingProperty = function(property, value){};
 /**
-* @param {Element} node Element to set attribute to.
-* @param {*} value Value to serialize.
-* @param {string} attribute Attribute name to serialize to.
+* @return {undefined}
 */
-Polymer_PropertyAccessors.prototype._valueToNodeAttribute = function(node, value, attribute){};
+Polymer_PropertiesChanged.prototype._invalidateProperties = function(){};
 /**
-* @param {*} value Property value to serialize.
-* @return {(string|undefined)}
+* @return {undefined}
 */
-Polymer_PropertyAccessors.prototype._serializeValue = function(value){};
+Polymer_PropertiesChanged.prototype._validateProperties = function(){};
 /**
-* @param {?string} value Attribute value to deserialize.
+* @return {undefined}
+*/
+Polymer_PropertiesChanged.prototype._enableProperties = function(){};
+/**
+* @return {undefined}
+*/
+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`
+*/
+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
+*/
+Polymer_PropertiesChanged.prototype.attributeChangedCallback = function(name, old, value){};
+/**
+* @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`
+*/
+Polymer_PropertiesChanged.prototype._attributeToProperty = function(attribute, value, type){};
+/**
+* @param {?string} value Value to deserialize.
 * @param {*=} type Type to deserialize the string to.
 * @return {*}
 */
-Polymer_PropertyAccessors.prototype._deserializeValue = function(value, type){};
+Polymer_PropertiesChanged.prototype._deserializeValue = function(value, type){};
+/**
+* @param {string} attribute Attribute to convert
+* @return {string}
+*/
+Polymer_PropertiesChanged.prototype._propertyForAttribute = function(attribute){};
+/**
+* @param {string} property Property to convert
+* @return {string}
+*/
+Polymer_PropertiesChanged.prototype._attributeForProperty = function(property){};
+/**
+* @param {string} name Name of property
+*/
+Polymer_PropertiesChanged.prototype._typeForProperty = function(name){};
+/**
+* @param {Array} props Array of names of accessors.
+*/
+Polymer_PropertiesChanged.createProperties = function(props){};
+/**
+* @interface
+* @extends {Polymer_PropertiesChanged}
+*/
+function Polymer_PropertyAccessors(){}
+/** @type {boolean} */
+Polymer_PropertyAccessors.prototype.__serializing;
+
+/** @type {number} */
+Polymer_PropertyAccessors.prototype.__dataCounter;
+
 /**
 * @param {string} property Name of the property
 * @param {boolean=} readOnly When true, no setter is created; the
@@ -112,42 +144,62 @@ Polymer_PropertyAccessors.prototype._deserializeValue = function(value, type){};
 */
 Polymer_PropertyAccessors.prototype._createPropertyAccessor = function(property, readOnly){};
 /**
-* @param {string} property Property name
-* @return {boolean}
+* @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.
 */
-Polymer_PropertyAccessors.prototype._hasAccessor = function(property){};
+Polymer_PropertyAccessors.prototype._generatePropertyAccessor = function(property, readOnly){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertyAccessors.prototype.ready = function(){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertyAccessors.prototype._initializeProperties = function(){};
+/**
+* @param {Object} props Bag of property values that were overwritten
+  when creating property accessors.
+*/
+Polymer_PropertyAccessors.prototype._initializeInstanceProperties = function(props){};
 /**
 * @param {string} property Name of the property
 * @param {*} value Value to set
 */
 Polymer_PropertyAccessors.prototype._setProperty = function(property, value){};
 /**
+* @param {string} property Name of property
+* @return {*}
+*/
+Polymer_PropertyAccessors.prototype._getProperty = function(property){};
+/**
 * @param {string} property Name of the property
 * @param {*} value Value to set
 * @return {boolean}
 */
 Polymer_PropertyAccessors.prototype._setPendingProperty = function(property, value){};
 /**
-* @param {string} prop Property name
-* @return {boolean}
-*/
-Polymer_PropertyAccessors.prototype._isPropertyPending = function(prop){};
-/**
 * @return {undefined}
 */
 Polymer_PropertyAccessors.prototype._invalidateProperties = function(){};
 /**
 * @return {undefined}
 */
-Polymer_PropertyAccessors.prototype._enableProperties = function(){};
+Polymer_PropertyAccessors.prototype._validateProperties = function(){};
 /**
 * @return {undefined}
 */
-Polymer_PropertyAccessors.prototype._flushProperties = function(){};
+Polymer_PropertyAccessors.prototype._enableProperties = function(){};
 /**
 * @return {undefined}
 */
-Polymer_PropertyAccessors.prototype.ready = function(){};
+Polymer_PropertyAccessors.prototype._flushProperties = function(){};
 /**
 * @param {!Object} currentProps Bag of all current accessor values
 * @param {!Object} changedProps Bag of properties changed since the last
@@ -164,6 +216,79 @@ Polymer_PropertyAccessors.prototype._propertiesChanged = function(currentProps,
 */
 Polymer_PropertyAccessors.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
+*/
+Polymer_PropertyAccessors.prototype.attributeChangedCallback = function(name, old, value){};
+/**
+* @param {string} attribute Name of attribute to deserialize.
+* @param {?string} value of the attribute.
+* @param {*=} type type to deserialize to.
+*/
+Polymer_PropertyAccessors.prototype._attributeToProperty = function(attribute, value, type){};
+/**
+* @param {?string} value Attribute value to deserialize.
+* @param {*=} type Type to deserialize the string to.
+* @return {*}
+*/
+Polymer_PropertyAccessors.prototype._deserializeValue = function(value, type){};
+/**
+* @param {string} attribute Attribute to convert
+* @return {string}
+*/
+Polymer_PropertyAccessors.prototype._propertyForAttribute = function(attribute){};
+/**
+* @param {string} property Property to convert
+* @return {string}
+*/
+Polymer_PropertyAccessors.prototype._attributeForProperty = function(property){};
+/**
+* @param {string} name Name of property
+*/
+Polymer_PropertyAccessors.prototype._typeForProperty = function(name){};
+/**
+* @param {Object} props Bag of property values that were overwritten
+  when creating property accessors.
+*/
+Polymer_PropertyAccessors.prototype._initializeProtoProperties = function(props){};
+/**
+* @param {string} attribute Name of attribute to ensure is set.
+* @param {string} value of the attribute.
+*/
+Polymer_PropertyAccessors.prototype._ensureAttribute = function(attribute, value){};
+/**
+* @param {string} property Property name to reflect.
+* @param {string=} attribute Attribute name to reflect.
+* @param {*=} value Property value to refect.
+*/
+Polymer_PropertyAccessors.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.
+*/
+Polymer_PropertyAccessors.prototype._valueToNodeAttribute = function(node, value, attribute){};
+/**
+* @param {*} value Property value to serialize.
+* @return {(string|undefined)}
+*/
+Polymer_PropertyAccessors.prototype._serializeValue = function(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 {Array} props Array of names of accessors.
+*/
+Polymer_PropertyAccessors.createProperties = function(props){};
+/**
 */
 Polymer_PropertyAccessors.createPropertiesForAttributes = function(){};
 /**
@@ -260,15 +385,6 @@ function Polymer_PropertyEffects(){}
 /** @type {number} */
 Polymer_PropertyEffects.prototype.__dataCounter;
 
-/** @type {!Object} */
-Polymer_PropertyEffects.prototype.__data;
-
-/** @type {!Object} */
-Polymer_PropertyEffects.prototype.__dataPending;
-
-/** @type {!Object} */
-Polymer_PropertyEffects.prototype.__dataOld;
-
 /** @type {boolean} */
 Polymer_PropertyEffects.prototype.__dataClientsReady;
 
@@ -296,6 +412,15 @@ 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;
 
@@ -345,115 +470,150 @@ Polymer_PropertyEffects.prototype._addEventListenerToNode = function(node, event
 */
 Polymer_PropertyEffects.prototype._removeEventListenerFromNode = function(node, eventName, handler){};
 /**
-* @param {string} name Name of attribute that changed
-* @param {?string} old Old attribute value
-* @param {?string} value New attribute value
+* @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
 */
-Polymer_PropertyEffects.prototype.attributeChangedCallback = function(name, old, value){};
+Polymer_PropertyEffects.prototype._createPropertyAccessor = function(property, readOnly){};
 /**
-* @return {undefined}
+* @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.
 */
-Polymer_PropertyEffects.prototype._initializeProperties = function(){};
+Polymer_PropertyEffects.prototype._generatePropertyAccessor = function(property, readOnly){};
 /**
 * @override
-* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_PropertyEffects.prototype._initializeProtoProperties = function(props){};
+Polymer_PropertyEffects.prototype.ready = function(){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertyEffects.prototype._initializeProperties = function(){};
 /**
 * @override
 * @param {Object} props Properties to initialize on the instance
 */
 Polymer_PropertyEffects.prototype._initializeInstanceProperties = function(props){};
 /**
-* @param {string} attribute Name of attribute to ensure is set.
-* @param {string} value of the attribute.
+* @override
 */
-Polymer_PropertyEffects.prototype._ensureAttribute = function(attribute, value){};
+Polymer_PropertyEffects.prototype._setProperty = function(property, value){};
 /**
-* @param {string} attribute Name of attribute to deserialize.
-* @param {?string} value of the attribute.
-* @param {*=} type type to deserialize to.
+* @param {string} property Name of property
+* @return {*}
 */
-Polymer_PropertyEffects.prototype._attributeToProperty = function(attribute, value, type){};
+Polymer_PropertyEffects.prototype._getProperty = function(property){};
 /**
-* @param {string} property Property name to reflect.
-* @param {string=} attribute Attribute name to reflect.
-* @param {*=} value Property value to refect.
+* @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._propertyToAttribute = function(property, attribute, value){};
+Polymer_PropertyEffects.prototype._setPendingProperty = function(property, value, shouldNotify){};
 /**
-* @param {Element} node Element to set attribute to.
-* @param {*} value Value to serialize.
-* @param {string} attribute Attribute name to serialize to.
+* @override
 */
-Polymer_PropertyEffects.prototype._valueToNodeAttribute = function(node, value, attribute){};
+Polymer_PropertyEffects.prototype._invalidateProperties = function(){};
 /**
-* @param {*} value Property value to serialize.
-* @return {(string|undefined)}
+* @return {undefined}
 */
-Polymer_PropertyEffects.prototype._serializeValue = function(value){};
+Polymer_PropertyEffects.prototype._validateProperties = function(){};
 /**
-* @param {?string} value Attribute value to deserialize.
-* @param {*=} type Type to deserialize the string to.
-* @return {*}
+* @return {undefined}
 */
-Polymer_PropertyEffects.prototype._deserializeValue = function(value, type){};
+Polymer_PropertyEffects.prototype._enableProperties = function(){};
 /**
-* @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 {undefined}
 */
-Polymer_PropertyEffects.prototype._createPropertyAccessor = function(property, readOnly){};
+Polymer_PropertyEffects.prototype._flushProperties = function(){};
+/**
+* @override
+*/
+Polymer_PropertyEffects.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
 /**
 * @param {string} property Property name
+* @param {*} value New property value
+* @param {*} old Previous property value
 * @return {boolean}
 */
-Polymer_PropertyEffects.prototype._hasAccessor = function(property){};
+Polymer_PropertyEffects.prototype._shouldPropertyChange = function(property, value, old){};
 /**
-* @override
+* @param {string} name Name of attribute that changed
+* @param {?string} old Old attribute value
+* @param {?string} value New attribute value
 */
-Polymer_PropertyEffects.prototype._setProperty = function(property, value){};
+Polymer_PropertyEffects.prototype.attributeChangedCallback = function(name, old, 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}
+* @param {string} attribute Name of attribute to deserialize.
+* @param {?string} value of the attribute.
+* @param {*=} type type to deserialize to.
 */
-Polymer_PropertyEffects.prototype._setPendingProperty = function(property, value, shouldNotify){};
+Polymer_PropertyEffects.prototype._attributeToProperty = function(attribute, value, type){};
 /**
-* @param {string} prop Property name
-* @return {boolean}
+* @param {?string} value Attribute value to deserialize.
+* @param {*=} type Type to deserialize the string to.
+* @return {*}
 */
-Polymer_PropertyEffects.prototype._isPropertyPending = function(prop){};
+Polymer_PropertyEffects.prototype._deserializeValue = function(value, type){};
 /**
-* @override
+* @param {string} attribute Attribute to convert
+* @return {string}
 */
-Polymer_PropertyEffects.prototype._invalidateProperties = function(){};
+Polymer_PropertyEffects.prototype._propertyForAttribute = function(attribute){};
 /**
-* @return {undefined}
+* @param {string} property Property to convert
+* @return {string}
 */
-Polymer_PropertyEffects.prototype._enableProperties = function(){};
+Polymer_PropertyEffects.prototype._attributeForProperty = function(property){};
 /**
-* @return {undefined}
+* @param {string} name Name of property
 */
-Polymer_PropertyEffects.prototype._flushProperties = function(){};
+Polymer_PropertyEffects.prototype._typeForProperty = function(name){};
 /**
 * @override
+* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_PropertyEffects.prototype.ready = function(){};
+Polymer_PropertyEffects.prototype._initializeProtoProperties = function(props){};
 /**
-* @override
+* @param {string} attribute Name of attribute to ensure is set.
+* @param {string} value of the attribute.
 */
-Polymer_PropertyEffects.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
+Polymer_PropertyEffects.prototype._ensureAttribute = function(attribute, value){};
+/**
+* @param {string} property Property name to reflect.
+* @param {string=} attribute Attribute name to reflect.
+* @param {*=} value Property value to refect.
+*/
+Polymer_PropertyEffects.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.
+*/
+Polymer_PropertyEffects.prototype._valueToNodeAttribute = function(node, value, attribute){};
+/**
+* @param {*} value Property value to serialize.
+* @return {(string|undefined)}
+*/
+Polymer_PropertyEffects.prototype._serializeValue = function(value){};
+/**
+* @param {string} property Property name
+* @return {boolean}
+*/
+Polymer_PropertyEffects.prototype._hasAccessor = function(property){};
 /**
-* @param {string} property Property name
-* @param {*} value New property value
-* @param {*} old Previous property value
+* @param {string} prop Property name
 * @return {boolean}
 */
-Polymer_PropertyEffects.prototype._shouldPropertyChange = function(property, value, old){};
+Polymer_PropertyEffects.prototype._isPropertyPending = function(prop){};
 /**
 * @param {string} property Property that should trigger the effect
 * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
@@ -730,6 +890,10 @@ Polymer_PropertyEffects._parseTemplateNodeAttribute = function(node, templateInf
 */
 Polymer_PropertyEffects._contentForTemplate = function(template){};
 /**
+* @param {Array} props Array of names of accessors.
+*/
+Polymer_PropertyEffects.createProperties = function(props){};
+/**
 */
 Polymer_PropertyEffects.createPropertiesForAttributes = function(){};
 /**
@@ -852,116 +1016,151 @@ Polymer_ElementMixin.prototype._addEventListenerToNode = function(node, eventNam
 */
 Polymer_ElementMixin.prototype._removeEventListenerFromNode = function(node, eventName, handler){};
 /**
-* @override
-* @param {string} name Name of attribute.
-* @param {?string} old Old value of attribute.
-* @param {?string} value Current value of attribute.
+* @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
 */
-Polymer_ElementMixin.prototype.attributeChangedCallback = function(name, old, value){};
+Polymer_ElementMixin.prototype._createPropertyAccessor = function(property, readOnly){};
+/**
+* @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.
+*/
+Polymer_ElementMixin.prototype._generatePropertyAccessor = function(property, readOnly){};
 /**
 * @override
 */
-Polymer_ElementMixin.prototype._initializeProperties = function(){};
+Polymer_ElementMixin.prototype.ready = function(){};
 /**
 * @override
-* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_ElementMixin.prototype._initializeProtoProperties = function(props){};
+Polymer_ElementMixin.prototype._initializeProperties = function(){};
 /**
 * @override
 * @param {Object} props Properties to initialize on the instance
 */
 Polymer_ElementMixin.prototype._initializeInstanceProperties = function(props){};
 /**
-* @param {string} attribute Name of attribute to ensure is set.
-* @param {string} value of the attribute.
+* @override
 */
-Polymer_ElementMixin.prototype._ensureAttribute = function(attribute, value){};
+Polymer_ElementMixin.prototype._setProperty = function(property, value){};
 /**
-* @param {string} attribute Name of attribute to deserialize.
-* @param {?string} value of the attribute.
-* @param {*=} type type to deserialize to.
+* @param {string} property Name of property
+* @return {*}
 */
-Polymer_ElementMixin.prototype._attributeToProperty = function(attribute, value, type){};
+Polymer_ElementMixin.prototype._getProperty = function(property){};
 /**
-* @param {string} property Property name to reflect.
-* @param {string=} attribute Attribute name to reflect.
-* @param {*=} value Property value to refect.
+* @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_ElementMixin.prototype._propertyToAttribute = function(property, attribute, value){};
+Polymer_ElementMixin.prototype._setPendingProperty = function(property, value, shouldNotify){};
 /**
-* @param {Element} node Element to set attribute to.
-* @param {*} value Value to serialize.
-* @param {string} attribute Attribute name to serialize to.
+* @override
 */
-Polymer_ElementMixin.prototype._valueToNodeAttribute = function(node, value, attribute){};
+Polymer_ElementMixin.prototype._invalidateProperties = function(){};
 /**
-* @param {*} value Property value to serialize.
-* @return {(string|undefined)}
+* @return {undefined}
 */
-Polymer_ElementMixin.prototype._serializeValue = function(value){};
+Polymer_ElementMixin.prototype._validateProperties = function(){};
 /**
-* @param {?string} value Attribute value to deserialize.
-* @param {*=} type Type to deserialize the string to.
-* @return {*}
+* @return {undefined}
 */
-Polymer_ElementMixin.prototype._deserializeValue = function(value, type){};
+Polymer_ElementMixin.prototype._enableProperties = function(){};
 /**
-* @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 {undefined}
 */
-Polymer_ElementMixin.prototype._createPropertyAccessor = function(property, readOnly){};
+Polymer_ElementMixin.prototype._flushProperties = function(){};
+/**
+* @override
+*/
+Polymer_ElementMixin.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
 /**
 * @param {string} property Property name
+* @param {*} value New property value
+* @param {*} old Previous property value
 * @return {boolean}
 */
-Polymer_ElementMixin.prototype._hasAccessor = function(property){};
+Polymer_ElementMixin.prototype._shouldPropertyChange = function(property, value, old){};
 /**
 * @override
+* @param {string} name Name of attribute.
+* @param {?string} old Old value of attribute.
+* @param {?string} value Current value of attribute.
 */
-Polymer_ElementMixin.prototype._setProperty = function(property, value){};
+Polymer_ElementMixin.prototype.attributeChangedCallback = function(name, old, 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}
+* @param {string} attribute Name of attribute to deserialize.
+* @param {?string} value of the attribute.
+* @param {*=} type type to deserialize to.
 */
-Polymer_ElementMixin.prototype._setPendingProperty = function(property, value, shouldNotify){};
+Polymer_ElementMixin.prototype._attributeToProperty = function(attribute, value, type){};
 /**
-* @param {string} prop Property name
-* @return {boolean}
+* @param {?string} value Attribute value to deserialize.
+* @param {*=} type Type to deserialize the string to.
+* @return {*}
 */
-Polymer_ElementMixin.prototype._isPropertyPending = function(prop){};
+Polymer_ElementMixin.prototype._deserializeValue = function(value, type){};
 /**
-* @override
+* @param {string} attribute Attribute to convert
+* @return {string}
 */
-Polymer_ElementMixin.prototype._invalidateProperties = function(){};
+Polymer_ElementMixin.prototype._propertyForAttribute = function(attribute){};
 /**
-* @return {undefined}
+* @param {string} property Property to convert
+* @return {string}
 */
-Polymer_ElementMixin.prototype._enableProperties = function(){};
+Polymer_ElementMixin.prototype._attributeForProperty = function(property){};
 /**
-* @return {undefined}
+* @param {string} name Name of property
 */
-Polymer_ElementMixin.prototype._flushProperties = function(){};
+Polymer_ElementMixin.prototype._typeForProperty = function(name){};
 /**
 * @override
+* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_ElementMixin.prototype.ready = function(){};
+Polymer_ElementMixin.prototype._initializeProtoProperties = function(props){};
 /**
-* @override
+* @param {string} attribute Name of attribute to ensure is set.
+* @param {string} value of the attribute.
 */
-Polymer_ElementMixin.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
+Polymer_ElementMixin.prototype._ensureAttribute = function(attribute, value){};
+/**
+* @param {string} property Property name to reflect.
+* @param {string=} attribute Attribute name to reflect.
+* @param {*=} value Property value to refect.
+*/
+Polymer_ElementMixin.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.
+*/
+Polymer_ElementMixin.prototype._valueToNodeAttribute = function(node, value, attribute){};
+/**
+* @param {*} value Property value to serialize.
+* @return {(string|undefined)}
+*/
+Polymer_ElementMixin.prototype._serializeValue = function(value){};
 /**
 * @param {string} property Property name
-* @param {*} value New property value
-* @param {*} old Previous property value
 * @return {boolean}
 */
-Polymer_ElementMixin.prototype._shouldPropertyChange = function(property, value, old){};
+Polymer_ElementMixin.prototype._hasAccessor = function(property){};
+/**
+* @param {string} prop Property name
+* @return {boolean}
+*/
+Polymer_ElementMixin.prototype._isPropertyPending = function(prop){};
 /**
 * @param {string} property Property that should trigger the effect
 * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
@@ -1261,6 +1460,10 @@ Polymer_ElementMixin._parseTemplateNodeAttribute = function(node, templateInfo,
 */
 Polymer_ElementMixin._contentForTemplate = function(template){};
 /**
+* @param {Array} props Array of names of accessors.
+*/
+Polymer_ElementMixin.createProperties = function(props){};
+/**
 */
 Polymer_ElementMixin.createPropertiesForAttributes = function(){};
 /**
@@ -1394,116 +1597,151 @@ Polymer_LegacyElementMixin.prototype._addEventListenerToNode = function(node, ev
 */
 Polymer_LegacyElementMixin.prototype._removeEventListenerFromNode = function(node, eventName, handler){};
 /**
-* @override
-* @param {string} name Name of attribute.
-* @param {?string} old Old value of attribute.
-* @param {?string} value Current value of attribute.
+* @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
 */
-Polymer_LegacyElementMixin.prototype.attributeChangedCallback = function(name, old, value){};
+Polymer_LegacyElementMixin.prototype._createPropertyAccessor = function(property, readOnly){};
+/**
+* @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.
+*/
+Polymer_LegacyElementMixin.prototype._generatePropertyAccessor = function(property, readOnly){};
 /**
 * @override
 */
-Polymer_LegacyElementMixin.prototype._initializeProperties = function(){};
+Polymer_LegacyElementMixin.prototype.ready = function(){};
 /**
 * @override
-* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_LegacyElementMixin.prototype._initializeProtoProperties = function(props){};
+Polymer_LegacyElementMixin.prototype._initializeProperties = function(){};
 /**
 * @override
 * @param {Object} props Properties to initialize on the instance
 */
 Polymer_LegacyElementMixin.prototype._initializeInstanceProperties = function(props){};
 /**
-* @param {string} attribute Name of attribute to ensure is set.
-* @param {string} value of the attribute.
+* @override
 */
-Polymer_LegacyElementMixin.prototype._ensureAttribute = function(attribute, value){};
+Polymer_LegacyElementMixin.prototype._setProperty = function(property, value){};
 /**
-* @param {string} attribute Name of attribute to deserialize.
-* @param {?string} value of the attribute.
-* @param {*=} type type to deserialize to.
+* @param {string} property Name of property
+* @return {*}
 */
-Polymer_LegacyElementMixin.prototype._attributeToProperty = function(attribute, value, type){};
+Polymer_LegacyElementMixin.prototype._getProperty = function(property){};
 /**
-* @param {string} property Property name to reflect.
-* @param {string=} attribute Attribute name to reflect.
-* @param {*=} value Property value to refect.
+* @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_LegacyElementMixin.prototype._propertyToAttribute = function(property, attribute, value){};
+Polymer_LegacyElementMixin.prototype._setPendingProperty = function(property, value, shouldNotify){};
 /**
-* @param {Element} node Element to set attribute to.
-* @param {*} value Value to serialize.
-* @param {string} attribute Attribute name to serialize to.
+* @override
 */
-Polymer_LegacyElementMixin.prototype._valueToNodeAttribute = function(node, value, attribute){};
+Polymer_LegacyElementMixin.prototype._invalidateProperties = function(){};
 /**
-* @param {*} value Property value to serialize.
-* @return {(string|undefined)}
+* @return {undefined}
 */
-Polymer_LegacyElementMixin.prototype._serializeValue = function(value){};
+Polymer_LegacyElementMixin.prototype._validateProperties = function(){};
 /**
-* @param {?string} value Attribute value to deserialize.
-* @param {*=} type Type to deserialize the string to.
-* @return {*}
+* @return {undefined}
 */
-Polymer_LegacyElementMixin.prototype._deserializeValue = function(value, type){};
+Polymer_LegacyElementMixin.prototype._enableProperties = function(){};
 /**
-* @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 {undefined}
 */
-Polymer_LegacyElementMixin.prototype._createPropertyAccessor = function(property, readOnly){};
+Polymer_LegacyElementMixin.prototype._flushProperties = function(){};
+/**
+* @override
+*/
+Polymer_LegacyElementMixin.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
 /**
 * @param {string} property Property name
+* @param {*} value New property value
+* @param {*} old Previous property value
 * @return {boolean}
 */
-Polymer_LegacyElementMixin.prototype._hasAccessor = function(property){};
+Polymer_LegacyElementMixin.prototype._shouldPropertyChange = function(property, value, old){};
 /**
 * @override
+* @param {string} name Name of attribute.
+* @param {?string} old Old value of attribute.
+* @param {?string} value Current value of attribute.
 */
-Polymer_LegacyElementMixin.prototype._setProperty = function(property, value){};
+Polymer_LegacyElementMixin.prototype.attributeChangedCallback = function(name, old, 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}
+* @param {string} attribute Name of attribute to deserialize.
+* @param {?string} value of the attribute.
+* @param {*=} type type to deserialize to.
 */
-Polymer_LegacyElementMixin.prototype._setPendingProperty = function(property, value, shouldNotify){};
+Polymer_LegacyElementMixin.prototype._attributeToProperty = function(attribute, value, type){};
 /**
-* @param {string} prop Property name
-* @return {boolean}
+* @param {?string} value Attribute value to deserialize.
+* @param {*=} type Type to deserialize the string to.
+* @return {*}
 */
-Polymer_LegacyElementMixin.prototype._isPropertyPending = function(prop){};
+Polymer_LegacyElementMixin.prototype._deserializeValue = function(value, type){};
+/**
+* @param {string} attribute Attribute to convert
+* @return {string}
+*/
+Polymer_LegacyElementMixin.prototype._propertyForAttribute = function(attribute){};
+/**
+* @param {string} property Property to convert
+* @return {string}
+*/
+Polymer_LegacyElementMixin.prototype._attributeForProperty = function(property){};
+/**
+* @param {string} name Name of property
+*/
+Polymer_LegacyElementMixin.prototype._typeForProperty = function(name){};
 /**
 * @override
+* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_LegacyElementMixin.prototype._invalidateProperties = function(){};
+Polymer_LegacyElementMixin.prototype._initializeProtoProperties = function(props){};
 /**
-* @return {undefined}
+* @param {string} attribute Name of attribute to ensure is set.
+* @param {string} value of the attribute.
+*/
+Polymer_LegacyElementMixin.prototype._ensureAttribute = function(attribute, value){};
+/**
+* @param {string} property Property name to reflect.
+* @param {string=} attribute Attribute name to reflect.
+* @param {*=} value Property value to refect.
 */
-Polymer_LegacyElementMixin.prototype._enableProperties = function(){};
+Polymer_LegacyElementMixin.prototype._propertyToAttribute = function(property, attribute, value){};
 /**
-* @return {undefined}
+* @param {Element} node Element to set attribute to.
+* @param {*} value Value to serialize.
+* @param {string} attribute Attribute name to serialize to.
 */
-Polymer_LegacyElementMixin.prototype._flushProperties = function(){};
+Polymer_LegacyElementMixin.prototype._valueToNodeAttribute = function(node, value, attribute){};
 /**
-* @override
+* @param {*} value Property value to serialize.
+* @return {(string|undefined)}
 */
-Polymer_LegacyElementMixin.prototype.ready = function(){};
+Polymer_LegacyElementMixin.prototype._serializeValue = function(value){};
 /**
-* @override
+* @param {string} property Property name
+* @return {boolean}
 */
-Polymer_LegacyElementMixin.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
+Polymer_LegacyElementMixin.prototype._hasAccessor = function(property){};
 /**
-* @param {string} property Property name
-* @param {*} value New property value
-* @param {*} old Previous property value
+* @param {string} prop Property name
 * @return {boolean}
 */
-Polymer_LegacyElementMixin.prototype._shouldPropertyChange = function(property, value, old){};
+Polymer_LegacyElementMixin.prototype._isPropertyPending = function(prop){};
 /**
 * @param {string} property Property that should trigger the effect
 * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
@@ -2096,6 +2334,10 @@ Polymer_LegacyElementMixin._parseTemplateNodeAttribute = function(node, template
 */
 Polymer_LegacyElementMixin._contentForTemplate = function(template){};
 /**
+* @param {Array} props Array of names of accessors.
+*/
+Polymer_LegacyElementMixin.createProperties = function(props){};
+/**
 */
 Polymer_LegacyElementMixin.createPropertiesForAttributes = function(){};
 /**
@@ -2243,116 +2485,151 @@ Polymer_ArraySelectorMixin.prototype._addEventListenerToNode = function(node, ev
 */
 Polymer_ArraySelectorMixin.prototype._removeEventListenerFromNode = function(node, eventName, handler){};
 /**
-* @override
-* @param {string} name Name of attribute.
-* @param {?string} old Old value of attribute.
-* @param {?string} value Current value of attribute.
+* @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
 */
-Polymer_ArraySelectorMixin.prototype.attributeChangedCallback = function(name, old, value){};
+Polymer_ArraySelectorMixin.prototype._createPropertyAccessor = function(property, readOnly){};
+/**
+* @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.
+*/
+Polymer_ArraySelectorMixin.prototype._generatePropertyAccessor = function(property, readOnly){};
 /**
 * @override
 */
-Polymer_ArraySelectorMixin.prototype._initializeProperties = function(){};
+Polymer_ArraySelectorMixin.prototype.ready = function(){};
 /**
 * @override
-* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_ArraySelectorMixin.prototype._initializeProtoProperties = function(props){};
+Polymer_ArraySelectorMixin.prototype._initializeProperties = function(){};
 /**
 * @override
 * @param {Object} props Properties to initialize on the instance
 */
 Polymer_ArraySelectorMixin.prototype._initializeInstanceProperties = function(props){};
 /**
-* @param {string} attribute Name of attribute to ensure is set.
-* @param {string} value of the attribute.
+* @override
 */
-Polymer_ArraySelectorMixin.prototype._ensureAttribute = function(attribute, value){};
+Polymer_ArraySelectorMixin.prototype._setProperty = function(property, value){};
 /**
-* @param {string} attribute Name of attribute to deserialize.
-* @param {?string} value of the attribute.
-* @param {*=} type type to deserialize to.
+* @param {string} property Name of property
+* @return {*}
 */
-Polymer_ArraySelectorMixin.prototype._attributeToProperty = function(attribute, value, type){};
+Polymer_ArraySelectorMixin.prototype._getProperty = function(property){};
 /**
-* @param {string} property Property name to reflect.
-* @param {string=} attribute Attribute name to reflect.
-* @param {*=} value Property value to refect.
+* @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_ArraySelectorMixin.prototype._propertyToAttribute = function(property, attribute, value){};
+Polymer_ArraySelectorMixin.prototype._setPendingProperty = function(property, value, shouldNotify){};
 /**
-* @param {Element} node Element to set attribute to.
-* @param {*} value Value to serialize.
-* @param {string} attribute Attribute name to serialize to.
+* @override
 */
-Polymer_ArraySelectorMixin.prototype._valueToNodeAttribute = function(node, value, attribute){};
+Polymer_ArraySelectorMixin.prototype._invalidateProperties = function(){};
 /**
-* @param {*} value Property value to serialize.
-* @return {(string|undefined)}
+* @return {undefined}
 */
-Polymer_ArraySelectorMixin.prototype._serializeValue = function(value){};
+Polymer_ArraySelectorMixin.prototype._validateProperties = function(){};
 /**
-* @param {?string} value Attribute value to deserialize.
-* @param {*=} type Type to deserialize the string to.
-* @return {*}
+* @return {undefined}
 */
-Polymer_ArraySelectorMixin.prototype._deserializeValue = function(value, type){};
+Polymer_ArraySelectorMixin.prototype._enableProperties = function(){};
 /**
-* @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 {undefined}
 */
-Polymer_ArraySelectorMixin.prototype._createPropertyAccessor = function(property, readOnly){};
+Polymer_ArraySelectorMixin.prototype._flushProperties = function(){};
+/**
+* @override
+*/
+Polymer_ArraySelectorMixin.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
 /**
 * @param {string} property Property name
+* @param {*} value New property value
+* @param {*} old Previous property value
 * @return {boolean}
 */
-Polymer_ArraySelectorMixin.prototype._hasAccessor = function(property){};
+Polymer_ArraySelectorMixin.prototype._shouldPropertyChange = function(property, value, old){};
 /**
 * @override
+* @param {string} name Name of attribute.
+* @param {?string} old Old value of attribute.
+* @param {?string} value Current value of attribute.
 */
-Polymer_ArraySelectorMixin.prototype._setProperty = function(property, value){};
+Polymer_ArraySelectorMixin.prototype.attributeChangedCallback = function(name, old, 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}
+* @param {string} attribute Name of attribute to deserialize.
+* @param {?string} value of the attribute.
+* @param {*=} type type to deserialize to.
 */
-Polymer_ArraySelectorMixin.prototype._setPendingProperty = function(property, value, shouldNotify){};
+Polymer_ArraySelectorMixin.prototype._attributeToProperty = function(attribute, value, type){};
 /**
-* @param {string} prop Property name
-* @return {boolean}
+* @param {?string} value Attribute value to deserialize.
+* @param {*=} type Type to deserialize the string to.
+* @return {*}
 */
-Polymer_ArraySelectorMixin.prototype._isPropertyPending = function(prop){};
+Polymer_ArraySelectorMixin.prototype._deserializeValue = function(value, type){};
 /**
-* @override
+* @param {string} attribute Attribute to convert
+* @return {string}
 */
-Polymer_ArraySelectorMixin.prototype._invalidateProperties = function(){};
+Polymer_ArraySelectorMixin.prototype._propertyForAttribute = function(attribute){};
 /**
-* @return {undefined}
+* @param {string} property Property to convert
+* @return {string}
 */
-Polymer_ArraySelectorMixin.prototype._enableProperties = function(){};
+Polymer_ArraySelectorMixin.prototype._attributeForProperty = function(property){};
 /**
-* @return {undefined}
+* @param {string} name Name of property
 */
-Polymer_ArraySelectorMixin.prototype._flushProperties = function(){};
+Polymer_ArraySelectorMixin.prototype._typeForProperty = function(name){};
 /**
 * @override
+* @param {Object} props Properties to initialize on the prototype
 */
-Polymer_ArraySelectorMixin.prototype.ready = function(){};
+Polymer_ArraySelectorMixin.prototype._initializeProtoProperties = function(props){};
 /**
-* @override
+* @param {string} attribute Name of attribute to ensure is set.
+* @param {string} value of the attribute.
 */
-Polymer_ArraySelectorMixin.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
+Polymer_ArraySelectorMixin.prototype._ensureAttribute = function(attribute, value){};
+/**
+* @param {string} property Property name to reflect.
+* @param {string=} attribute Attribute name to reflect.
+* @param {*=} value Property value to refect.
+*/
+Polymer_ArraySelectorMixin.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.
+*/
+Polymer_ArraySelectorMixin.prototype._valueToNodeAttribute = function(node, value, attribute){};
+/**
+* @param {*} value Property value to serialize.
+* @return {(string|undefined)}
+*/
+Polymer_ArraySelectorMixin.prototype._serializeValue = function(value){};
 /**
 * @param {string} property Property name
-* @param {*} value New property value
-* @param {*} old Previous property value
 * @return {boolean}
 */
-Polymer_ArraySelectorMixin.prototype._shouldPropertyChange = function(property, value, old){};
+Polymer_ArraySelectorMixin.prototype._hasAccessor = function(property){};
+/**
+* @param {string} prop Property name
+* @return {boolean}
+*/
+Polymer_ArraySelectorMixin.prototype._isPropertyPending = function(prop){};
 /**
 * @param {string} property Property that should trigger the effect
 * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
@@ -2682,6 +2959,10 @@ Polymer_ArraySelectorMixin._parseTemplateNodeAttribute = function(node, template
 */
 Polymer_ArraySelectorMixin._contentForTemplate = function(template){};
 /**
+* @param {Array} props Array of names of accessors.
+*/
+Polymer_ArraySelectorMixin.createProperties = function(props){};
+/**
 */
 Polymer_ArraySelectorMixin.createPropertiesForAttributes = function(){};
 /**
@@ -2755,4 +3036,134 @@ Polymer_ArraySelectorMixin._parseBindings = function(text, templateInfo){};
 Polymer_ArraySelectorMixin._evaluateBinding = function(inst, part, path, props, oldProps, hasPaths){};
 /**
 */
-Polymer_ArraySelectorMixin.finalize = function(){};
\ No newline at end of file
+Polymer_ArraySelectorMixin.finalize = function(){};
+/**
+* @interface
+* @extends {Polymer_PropertiesChanged}
+*/
+function Polymer_PropertiesMixin(){}
+/**
+* @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
+*/
+Polymer_PropertiesMixin.prototype._createPropertyAccessor = function(property, readOnly){};
+/**
+* @param {string} property Name of the property
+* @param {boolean=} readOnly When true, no setter is created
+*/
+Polymer_PropertiesMixin.prototype._generatePropertyAccessor = function(property, readOnly){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertiesMixin.prototype.ready = function(){};
+/**
+* @override
+*/
+Polymer_PropertiesMixin.prototype._initializeProperties = function(){};
+/**
+* @param {Object} props Bag of property values that were overwritten
+  when creating property accessors.
+*/
+Polymer_PropertiesMixin.prototype._initializeInstanceProperties = function(props){};
+/**
+* @param {string} property Name of the property
+* @param {*} value Value to set
+*/
+Polymer_PropertiesMixin.prototype._setProperty = function(property, value){};
+/**
+* @param {string} property Name of property
+* @return {*}
+*/
+Polymer_PropertiesMixin.prototype._getProperty = function(property){};
+/**
+* @param {string} property Name of the property
+* @param {*} value Value to set
+* @return {boolean}
+*/
+Polymer_PropertiesMixin.prototype._setPendingProperty = function(property, value){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertiesMixin.prototype._invalidateProperties = function(){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertiesMixin.prototype._validateProperties = function(){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertiesMixin.prototype._enableProperties = function(){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertiesMixin.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`
+*/
+Polymer_PropertiesMixin.prototype._propertiesChanged = function(currentProps, changedProps, oldProps){};
+/**
+* @param {string} property Property name
+* @param {*} value New property value
+* @param {*} old Previous property value
+* @return {boolean}
+*/
+Polymer_PropertiesMixin.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
+*/
+Polymer_PropertiesMixin.prototype.attributeChangedCallback = function(name, old, value){};
+/**
+* @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`
+*/
+Polymer_PropertiesMixin.prototype._attributeToProperty = function(attribute, value, type){};
+/**
+* @param {?string} value Value to deserialize.
+* @param {*=} type Type to deserialize the string to.
+* @return {*}
+*/
+Polymer_PropertiesMixin.prototype._deserializeValue = function(value, type){};
+/**
+* @param {string} attribute Attribute to convert
+* @return {string}
+*/
+Polymer_PropertiesMixin.prototype._propertyForAttribute = function(attribute){};
+/**
+* @param {string} property Property to convert
+* @return {string}
+*/
+Polymer_PropertiesMixin.prototype._attributeForProperty = function(property){};
+/**
+* @param {string} name Name of property
+* @return {*}
+*/
+Polymer_PropertiesMixin.prototype._typeForProperty = function(name){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertiesMixin.prototype.connectedCallback = function(){};
+/**
+* @return {undefined}
+*/
+Polymer_PropertiesMixin.prototype.disconnectedCallback = function(){};
+/**
+* @param {Array} props Array of names of accessors.
+*/
+Polymer_PropertiesMixin.createProperties = function(props){};
+/**
+* @param {*} name 
+*/
+Polymer_PropertiesMixin._ensureFinalized = function(name){};
+/**
+* @param {string} name Name of the element
+*/
+Polymer_PropertiesMixin.finalize = function(name){};
\ No newline at end of file
diff --git a/externs/polymer-closure-types.html b/externs/polymer-closure-types.html
index faf9152e1b..0c499ecee8 100644
--- a/externs/polymer-closure-types.html
+++ b/externs/polymer-closure-types.html
@@ -154,4 +154,8 @@
    * }}
    */
   let TemplatizeOptions;
+
+
+  /** @typedef {{run: function(function(), number=):number, cancel: function(number)}} */
+  let AsyncInterface;
 </script>
\ No newline at end of file
diff --git a/gulpfile.js b/gulpfile.js
index aa6d6b1f1f..7d53afb248 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -144,7 +144,7 @@ gulp.task('closure', ['clean'], () => {
   if (CLOSURE_LINT_ONLY) {
     closurePluginOptions = {
       logger: closureLintLogger
-    }
+    };
   }
 
   const closureStream = closure({
diff --git a/lib/elements/properties-element.html b/lib/elements/properties-element.html
index e0e8f13615..3972e2e364 100644
--- a/lib/elements/properties-element.html
+++ b/lib/elements/properties-element.html
@@ -13,36 +13,30 @@
 <link rel="import" href="../mixins/properties-mixin.html">
 
 <script>
-(function() {
+  (function () {
 
-  'use strict';
+    'use strict';
 
-  /**
-   * Base class that provides a simple starting point for creating an element
-   * that declares properties via the `properties` static getter that are
-   * observed. Changes are reported via the `_propertiesChanged` method.
-   * This element provides no specific support for rendering. Users are expected
-   * to create a shadowRoot and put content into it and update it in whatever
-   * way makes sense for the use case.
-   *
-   * @customElement
-   * @polymer
-   * @memberof Polymer
-   * @constructor
-   * @implements {Polymer_PropertiesMixin}
-   * @extends HTMLElement
-   * @appliesMixin Polymer.PropertiesMixin
-   * @summary Base class that provides a simple starting point for creating an
-   * element that declares properties via the `properties` static getter that
-   * are observed
-   */
-   const PropertiesElement = Polymer.PropertiesMixin(HTMLElement);
-  /**
-   * @constructor
-   * @implements {Polymer_PropertiesMixin}
-   * @extends {HTMLElement}
-   */
-  Polymer.PropertiesElement = PropertiesElement;
-
-})();
-</script>
+    /**
+     * Base class that provides a simple starting point for creating an element
+     * that declares properties via the `properties` static getter that are
+     * observed. Changes are reported via the `_propertiesChanged` method.
+     * This element provides no specific support for rendering. Users are expected
+     * to create a shadowRoot and put content into it and update it in whatever
+     * way makes sense for the use case.
+     *
+     * @customElement
+     * @polymer
+     * @memberof Polymer
+     * @constructor
+     * @implements {Polymer_PropertiesMixin}
+     * @extends HTMLElement
+     * @appliesMixin Polymer.PropertiesMixin
+     * @summary Base class that provides a simple starting point for creating an
+     * element that declares properties via the `properties` static getter that
+     * are observed
+     */
+    const PropertiesElement = Polymer.PropertiesMixin(HTMLElement);
+    Polymer.PropertiesElement = PropertiesElement;
+  })();
+</script>
\ No newline at end of file
diff --git a/lib/mixins/properties-changed.html b/lib/mixins/properties-changed.html
index e0fce0eb22..80b595c4ad 100644
--- a/lib/mixins/properties-changed.html
+++ b/lib/mixins/properties-changed.html
@@ -13,398 +13,408 @@
 <link rel="import" href="../utils/async.html">
 
 <script>
-(function() {
-
-  'use strict';
-
-  let microtask = Polymer.Async.microTask;
-
-  /**
-   * 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.
-   *
-   * @mixinFunction
-   * @polymer
-   * @memberof Polymer
-   * @summary Element class mixin for reacting to property changes from
-   *   generated property accessors.
-   */
-   Polymer.PropertiesChanged = Polymer.dedupingMixin(superClass => {
-
-    return class PropertiesChanged extends superClass {
+  (function () {
+
+    'use strict';
+
+    /** @const {!AsyncInterface} */
+    const microtask = Polymer.Async.microTask;
+
+    /**
+     * 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.
+     *
+     * @mixinFunction
+     * @polymer
+     * @memberof Polymer
+     * @summary Element class mixin for reacting to property changes from
+     *   generated property accessors.
+     */
+    Polymer.PropertiesChanged = Polymer.dedupingMixin(superClass => {
 
       /**
-       * Creates property accessors for the given property names.
-       * @param {array} props Array of names of accessors.
+       * @polymer
+       * @mixinClass
+       * @extends {superClass}
+       * @implements {Polymer_PropertiesChanged}
+       * @unrestricted
        */
-       static createProperties(props) {
-        for (let i=0; i < props.length; i++) {
-          this.prototype._createPropertyAccessor(props[i]);
+      class PropertiesChanged extends superClass {
+
+        /**
+         * Creates property accessors for the given property names.
+         * @param {Array} props Array of names of accessors.
+         */
+        static createProperties(props) {
+          for (let i = 0; i < props.length; i++) {
+            this.prototype._createPropertyAccessor(props[i]);
+          }
         }
-      }
 
-      /**
-       * 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.
-       *
-       * @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
-       * @protected
-       */
-      _createPropertyAccessor(property, readOnly) {
-        if (!this.hasOwnProperty('__dataHasAccessor')) {
-          this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);
-        }
-        if (!this.__dataHasAccessor[property]) {
-          this.__dataHasAccessor[property] = true;
-          this._generatePropertyAccessor(property, readOnly);
+        /**
+         * 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.
+         *
+         * @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
+         * @protected
+         */
+        _createPropertyAccessor(property, readOnly) {
+          if (!this.hasOwnProperty('__dataHasAccessor')) {
+            this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);
+          }
+          if (!this.__dataHasAccessor[property]) {
+            this.__dataHasAccessor[property] = true;
+            this._generatePropertyAccessor(property, readOnly);
+          }
         }
-      }
 
-      /**
-       * Generates a property accessor for the given property.
-       * @param {string} property Name of the property
-       * @param {boolean=} readOnly When true, no setter is created
-       */
-      _generatePropertyAccessor(property, readOnly) {
-        Object.defineProperty(this, property, {
-          /* eslint-disable valid-jsdoc */
-          /** @this {PropertiesChanged} */
-          get: function() {
-            return this.__data[property];
-          },
-          /** @this {PropertiesChanged} */
-          set: readOnly ? function() {} : function(value) {
-            this._setProperty(property, value);
-          }
-          /* eslint-enable */
-        });
-      }
+        /**
+         * Generates a property accessor for the given property.
+         * @param {string} property Name of the property
+         * @param {boolean=} readOnly When true, no setter is created
+         */
+        _generatePropertyAccessor(property, readOnly) {
+          Object.defineProperty(this, property, {
+            /* eslint-disable valid-jsdoc */
+            /** @this {PropertiesChanged} */
+            get() {
+              return this.__data[property];
+            },
+            /** @this {PropertiesChanged} */
+            set: readOnly ? function () {} : function (value) {
+              this._setProperty(property, value);
+            }
+            /* eslint-enable */
+          });
+        }
 
-      constructor() {
-        super();
-        this.__dataEnabled = false;
-        this.__dataReady = false;
-        this.__dataInvalid = false;
-        this.__data = {};
-        this.__dataPending = null;
-        this.__dataOld = null;
-        this.__dataInstanceProps = null;
-        this._initializeProperties();
-      }
+        constructor() {
+          super();
+          this.__dataEnabled = false;
+          this.__dataReady = false;
+          this.__dataInvalid = false;
+          this.__data = {};
+          this.__dataPending = null;
+          this.__dataOld = null;
+          this.__dataInstanceProps = null;
+          this._initializeProperties();
+        }
 
-      /**
-       * Lifecycle callback called when properties are enabled via
-       * `_enableProperties`.
-       *
-       * Users may override this function to implement behavior that is
-       * dependent on the element having its property data 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.
-       *
-       * @public
-       */
-       ready() {
-        this.__dataReady = true;
-      }
+        /**
+         * Lifecycle callback called when properties are enabled via
+         * `_enableProperties`.
+         *
+         * Users may override this function to implement behavior that is
+         * dependent on the element having its property data 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.
+         *
+         * @public
+         */
+        ready() {
+          this.__dataReady = true;
+        }
 
-      /**
-       * Initializes the local storage for property accessors.
-       *
-       * Provided as an override point for performing any setup work prior
-       * to initializing the property accessor system.
-       *
-       * @protected
-       */
-      _initializeProperties() {
-        // Capture instance properties; these will be set into accessors
-        // during first flush. Don't set them here, since we want
-        // these to overwrite defaults/constructor assignments
-        for (let p in this.__dataHasAccessor) {
-          if (this.hasOwnProperty(p)) {
-            this.__dataInstanceProps = this.__dataInstanceProps || {};
-            this.__dataInstanceProps[p] = this[p];
-            delete this[p];
+        /**
+         * Initializes the local storage for property accessors.
+         *
+         * Provided as an override point for performing any setup work prior
+         * to initializing the property accessor system.
+         *
+         * @protected
+         */
+        _initializeProperties() {
+          // Capture instance properties; these will be set into accessors
+          // during first flush. Don't set them here, since we want
+          // these to overwrite defaults/constructor assignments
+          for (let p in this.__dataHasAccessor) {
+            if (this.hasOwnProperty(p)) {
+              this.__dataInstanceProps = this.__dataInstanceProps || {};
+              this.__dataInstanceProps[p] = this[p];
+              delete this[p];
+            }
           }
         }
-      }
 
-      /**
-       * 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 {Object} props Bag of property values that were overwritten
-       *   when creating property accessors.
-       * @protected
-       */
-      _initializeInstanceProperties(props) {
-        Object.assign(this, props);
-      }
+        /**
+         * 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 {Object} props Bag of property values that were overwritten
+         *   when creating property accessors.
+         * @protected
+         */
+        _initializeInstanceProperties(props) {
+          Object.assign(this, props);
+        }
 
-      /**
-       * Updates the local storage for a property (via `_setPendingProperty`)
-       * and enqueues a `_proeprtiesChanged` callback.
-       *
-       * @param {string} property Name of the property
-       * @param {*} value Value to set
-       * @protected
-       */
-      _setProperty(property, value) {
-        if (this._setPendingProperty(property, value)) {
-          this._invalidateProperties();
+        /**
+         * Updates the local storage for a property (via `_setPendingProperty`)
+         * and enqueues a `_proeprtiesChanged` callback.
+         *
+         * @param {string} property Name of the property
+         * @param {*} value Value to set
+         * @protected
+         */
+        _setProperty(property, value) {
+          if (this._setPendingProperty(property, value)) {
+            this._invalidateProperties();
+          }
         }
-      }
 
-      /**
-       * Returns the value for the given property.
-       * @param {string} property Name of property
-       * @return {*} Value for the given property
-       * @protected
-       */
-      _getProperty(property) {
-        return this.__data[property];
-      }
+        /**
+         * Returns the value for the given property.
+         * @param {string} property Name of property
+         * @return {*} Value for the given property
+         * @protected
+         */
+        _getProperty(property) {
+          return this.__data[property];
+        }
 
-      /**
-       * 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 {string} property Name of the property
-       * @param {*} value Value to set
-       * @return {boolean} Returns true if the property changed
-       * @protected
-       */
-      _setPendingProperty(property, value) {
-        let old = this.__data[property];
-        let changed = this._shouldPropertyChange(property, value, old);
-        if (changed) {
-          if (!this.__dataPending) {
-            this.__dataPending = {};
-            this.__dataOld = {};
-          }
-          // Ensure old is captured from the last turn
-          if (this.__dataOld && !(property in this.__dataOld)) {
-            this.__dataOld[property] = old;
+        /**
+         * 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 {string} property Name of the property
+         * @param {*} value Value to set
+         * @return {boolean} Returns true if the property changed
+         * @protected
+         */
+        _setPendingProperty(property, value) {
+          let old = this.__data[property];
+          let changed = this._shouldPropertyChange(property, value, old);
+          if (changed) {
+            if (!this.__dataPending) {
+              this.__dataPending = {};
+              this.__dataOld = {};
+            }
+            // Ensure old is captured from the last turn
+            if (this.__dataOld && !(property in this.__dataOld)) {
+              this.__dataOld[property] = old;
+            }
+            this.__data[property] = value;
+            this.__dataPending[property] = value;
           }
-          this.__data[property] = value;
-          this.__dataPending[property] = value;
+          return changed;
         }
-        return changed;
-      }
 
-      /**
-       * Marks the properties as invalid, and enqueues an async
-       * `_propertiesChanged` callback.
-       *
-       * @protected
-       */
-      _invalidateProperties() {
-        if (!this.__dataInvalid && this.__dataReady) {
-          this.__dataInvalid = true;
-          microtask.run(() => this._validateProperties());
+        /**
+         * Marks the properties as invalid, and enqueues an async
+         * `_propertiesChanged` callback.
+         *
+         * @protected
+         */
+        _invalidateProperties() {
+          if (!this.__dataInvalid && this.__dataReady) {
+            this.__dataInvalid = true;
+            microtask.run(() => this._validateProperties());
+          }
         }
-      }
 
-      /**
-       * Changes are processed at microtask timing, but this method can be
-       * calleed to force any pending changes to be immediately processed.
-       * @protected
-       */
-      _validateProperties() {
-        if (this.__dataInvalid) {
-          this.__dataInvalid = false;
-          this._flushProperties();
+        /**
+         * Changes are processed at microtask timing, but this method can be
+         * calleed to force any pending changes to be immediately processed.
+         * @protected
+         */
+        _validateProperties() {
+          if (this.__dataInvalid) {
+            this.__dataInvalid = false;
+            this._flushProperties();
+          }
         }
-      }
 
-      /**
-       * 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.
-       *
-       * @protected
-       */
-      _enableProperties() {
-        if (!this.__dataEnabled) {
-          this.__dataEnabled = true;
-          if (this.__dataInstanceProps) {
-            this._initializeInstanceProperties(this.__dataInstanceProps);
-            this.__dataInstanceProps = null;
+        /**
+         * 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.
+         *
+         * @protected
+         */
+        _enableProperties() {
+          if (!this.__dataEnabled) {
+            this.__dataEnabled = true;
+            if (this.__dataInstanceProps) {
+              this._initializeInstanceProperties(this.__dataInstanceProps);
+              this.__dataInstanceProps = null;
+            }
+            this.ready();
           }
-          this.ready();
         }
-      }
 
-      /**
-       * 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.
-       *
-       *
-       * @protected
-       */
-      _flushProperties() {
-        let changedProps = this.__dataPending;
-        this.__dataPending = null;
-        this._propertiesChanged(this.__data, changedProps, this.__dataOld);
-      }
+        /**
+         * 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.
+         *
+         *
+         * @protected
+         */
+        _flushProperties() {
+          let changedProps = this.__dataPending;
+          this.__dataPending = null;
+          this._propertiesChanged(this.__data, changedProps, this.__dataOld);
+        }
 
-      /**
-       * Callback called when any properties with accessors created via
-       * `_createPropertyAccessor` have been set.
-       *
-       * @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`
-       * @protected
-       */
-      _propertiesChanged(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars
-      }
+        /**
+         * Callback called when any properties with accessors created via
+         * `_createPropertyAccessor` have been set.
+         *
+         * @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`
+         * @protected
+         */
+        _propertiesChanged(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars
+        }
 
-      /**
-       * 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 {string} property Property name
-       * @param {*} value New property value
-       * @param {*} old Previous property value
-       * @return {boolean} Whether the property should be considered a change
-       *   and enqueue a `_proeprtiesChanged` callback
-       * @protected
-       */
-      _shouldPropertyChange(property, value, old) {
-        return (
-          // Strict equality check
-          (old !== value &&
-            // This ensures (old==NaN, value==NaN) always returns false
-            (old === old || value === value))
-        );
-      }
+        /**
+         * 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 {string} property Property name
+         * @param {*} value New property value
+         * @param {*} old Previous property value
+         * @return {boolean} Whether the property should be considered a change
+         *   and enqueue a `_proeprtiesChanged` callback
+         * @protected
+         */
+        _shouldPropertyChange(property, value, old) {
+          return (
+            // Strict equality check
+            (old !== value &&
+              // This ensures (old==NaN, value==NaN) always returns false
+              (old === old || value === value))
+          );
+        }
 
-      /**
-       * Implements native Custom Elements `attributeChangedCallback` to
-       * set an attribute value to a property via `_attributeToProperty`.
-       *
-       * @param {string} name Name of attribute that changed
-       * @param {?string} old Old attribute value
-       * @param {?string} value New attribute value
-       */
-      attributeChangedCallback(name, old, value) {
-        if (old !== value) {
-          this._attributeToProperty(name, value);
+        /**
+         * Implements native Custom Elements `attributeChangedCallback` to
+         * set an attribute value to a property via `_attributeToProperty`.
+         *
+         * @param {string} name Name of attribute that changed
+         * @param {?string} old Old attribute value
+         * @param {?string} value New attribute value
+         */
+        attributeChangedCallback(name, old, value) {
+          if (old !== value) {
+            this._attributeToProperty(name, value);
+          }
         }
-      }
 
-      /**
-       * Deserializes an attribute to its associated property.
-       *
-       * This method calls the `_deserializeValue` method to convert the string to
-       * a typed value.
-       *
-       * @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`
-       */
-      _attributeToProperty(attribute, value, type) {
-        const property = this._propertyForAttribute(attribute);
-        this[property] = this._deserializeValue(value, type ||
-          this._typeForProperty(property));
-      }
+        /**
+         * Deserializes an attribute to its associated property.
+         *
+         * This method calls the `_deserializeValue` method to convert the string to
+         * a typed value.
+         *
+         * @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`
+         */
+        _attributeToProperty(attribute, value, type) {
+          const property = this._propertyForAttribute(attribute);
+          this[property] = this._deserializeValue(value, type ||
+            this._typeForProperty(property));
+        }
 
-      /**
-       * Converts a string to a typed JavaScript value.
-       *
-       * This method is called when reading HTML attribute values to
-       * JS properties.  Users may override this method to provide
-       * deserialization for custom `type`s.
-       *
-       * @param {?string} value Value to deserialize.
-       * @param {*=} type Type to deserialize the string to.
-       * @return {*} Typed value deserialized from the provided string.
-       */
-      _deserializeValue(value, type) {
-        return typeof type == 'function' ? type(value) : value;
-      }
+        /**
+         * Converts a string to a typed JavaScript value.
+         *
+         * This method is called when reading HTML attribute values to
+         * JS properties.  Users may override this method to provide
+         * deserialization for custom `type`s.
+         *
+         * @param {?string} value Value to deserialize.
+         * @param {*=} type Type to deserialize the string to.
+         * @return {*} Typed value deserialized from the provided string.
+         */
+        _deserializeValue(value, type) {
+          return typeof type == 'function' ? type(value) : value;
+        }
 
-      /**
-       * Returns a property name that corresponds to the given attribute.
-       * By default, converts dash to camel case, e.g. `foo-bar` to `fooBar`.
-       * @param {string} attribute Attribute to convert
-       * @return {string} Property name corresponding to the given attribute.
-       *
-       * @protected
-       */
-       _propertyForAttribute(attribute) {
-        return attribute;
-      }
+        /**
+         * Returns a property name that corresponds to the given attribute.
+         * By default, converts dash to camel case, e.g. `foo-bar` to `fooBar`.
+         * @param {string} attribute Attribute to convert
+         * @return {string} Property name corresponding to the given attribute.
+         *
+         * @protected
+         */
+        _propertyForAttribute(attribute) {
+          return attribute;
+        }
 
-      /**
-       * Returns an attribute name that corresponds to the given property.
-       * By default, converts camel to dash case, e.g. `fooBar` to `foo-bar`.
-       * @param {string} property Property to convert
-       * @return {string} Attribute name corresponding to the given property.
-       *
-       * @protected
-       */
-      _attributeForProperty(property) {
-        return property;
-      }
+        /**
+         * Returns an attribute name that corresponds to the given property.
+         * By default, converts camel to dash case, e.g. `fooBar` to `foo-bar`.
+         * @param {string} property Property to convert
+         * @return {string} Attribute name corresponding to the given property.
+         *
+         * @protected
+         */
+        _attributeForProperty(property) {
+          return property;
+        }
 
-      /**
-       * Override point to provide a type to which to deserialize a value to
-       * a given property.
-       * @param {string} name Name of property
-       *
-       * @protected
-       */
-       _typeForProperty(name) {} //eslint-disable-line no-unused-vars
+        /**
+         * Override point to provide a type to which to deserialize a value to
+         * a given property.
+         * @param {string} name Name of property
+         *
+         * @protected
+         */
+        _typeForProperty(name) { } //eslint-disable-line no-unused-vars
+
+      }
 
-    };
+      return PropertiesChanged;
+    });
 
-  });
 
+  })();
 
-})();
-</script>
+</script>
\ No newline at end of file
diff --git a/lib/mixins/properties-mixin.html b/lib/mixins/properties-mixin.html
index 62695fa8ec..06c6359402 100644
--- a/lib/mixins/properties-mixin.html
+++ b/lib/mixins/properties-mixin.html
@@ -26,13 +26,10 @@
    * to create a shadowRoot and put content into it and update it in whatever
    * way makes sense for the use case.
    *
-   * @customElement
+   * @mixinFunction
    * @polymer
-   * @memberof Polymer
-   * @constructor
-   * @implements {Polymer_PropertiesChanged}
-   * @extends HTMLElement
    * @appliesMixin Polymer.PropertiesChanged
+   * @memberof Polymer
    * @summary Mixin that provides a minimal starting point for using
    * the PropertiesChanged mixin by providing a declarative `properties` object.
    */
@@ -42,11 +39,17 @@
      * @constructor
      * @extends {superClass}
      * @implements {Polymer_PropertiesChanged}
-     * @unrestricted
      */
     const base = Polymer.PropertiesChanged(superClass);
 
-    return class PropertiesElement extends base {
+    /**
+     * @polymer
+     * @mixinClass
+     * @extends {base}
+     * @implements {Polymer_PropertiesMixin}
+     * @unrestricted
+     */
+    class Properties extends base {
 
       /**
        * Implements standard custom elements getter to observes the attributes
@@ -131,7 +134,9 @@
        */
       disconnectedCallback() {}
 
-    };
+    }
+
+    return Properties;
 
   });
 
diff --git a/lib/mixins/property-accessors.html b/lib/mixins/property-accessors.html
index 369a636830..366fa05d82 100644
--- a/lib/mixins/property-accessors.html
+++ b/lib/mixins/property-accessors.html
@@ -86,6 +86,7 @@
    *
    * @mixinFunction
    * @polymer
+   * @appliesMixin Polymer.PropertiesChanged
    * @memberof Polymer
    * @summary Element class mixin for reacting to property changes from
    *   generated property accessors.
@@ -104,7 +105,7 @@
      * @polymer
      * @mixinClass
      * @implements {Polymer_PropertyAccessors}
-     * @extends HTMLElement
+     * @extends {base}
      * @unrestricted
      */
     class PropertyAccessors extends base {
@@ -195,13 +196,15 @@
        * Ensures the element has the given attribute. If it does not,
        * assigns the given value to the attribute.
        *
+       * @suppress {invalidCasts} Closure can't figure out `this` is infact an element
        *
        * @param {string} attribute Name of attribute to ensure is set.
        * @param {string} value of the attribute.
        */
       _ensureAttribute(attribute, value) {
-        if (!this.hasAttribute(attribute)) {
-          this._valueToNodeAttribute(this, value, attribute);
+        const el = /** @type {!HTMLElement} */(this);
+        if (!el.hasAttribute(attribute)) {
+          this._valueToNodeAttribute(el, value, attribute);
         }
       }
 
@@ -225,6 +228,8 @@
       /**
        * Serializes a property to its associated attribute.
        *
+       * @suppress {invalidCasts} Closure can't figure out `this` is an element.
+       *
        * @param {string} property Property name to reflect.
        * @param {string=} attribute Attribute name to reflect.
        * @param {*=} value Property value to refect.
@@ -232,8 +237,8 @@
       _propertyToAttribute(property, attribute, value) {
         this.__serializing = true;
         value = (arguments.length < 3) ? this[property] : value;
-        this._valueToNodeAttribute(this, value,
-          attribute || this._attributeNameForProperty(property));
+        this._valueToNodeAttribute(/** @type {!HTMLElement} */(this), value,
+          attribute || this._attributeForProperty(property));
         this.__serializing = false;
       }
 
diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index b88ed2e1b3..6c835a9069 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -8,7 +8,6 @@
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
 
-
 <link rel="import" href="../utils/boot.html">
 <link rel="import" href="../utils/mixin.html">
 <link rel="import" href="../utils/path.html">
diff --git a/lib/utils/async.html b/lib/utils/async.html
index f90bb033b6..33494436a7 100644
--- a/lib/utils/async.html
+++ b/lib/utils/async.html
@@ -14,9 +14,6 @@
 
   'use strict';
 
-  /** @typedef {{run: function(function(), number=):number, cancel: function(number)}} */
-  let AsyncInterface; // eslint-disable-line no-unused-vars
-
   // Microtask implemented using Mutation Observer
   let microtaskCurrHandle = 0;
   let microtaskLastHandle = 0;
@@ -67,11 +64,11 @@
        * delay.
        *
        * @memberof Polymer.Async.timeOut
-       * @param {number} delay Time to wait before calling callbacks in ms
+       * @param {number=} delay Time to wait before calling callbacks in ms
        * @return {AsyncInterface} An async timeout interface
        */
       after(delay) {
-        return  {
+        return {
           run(fn) { return setTimeout(fn, delay); },
           cancel(handle) {
             window.clearTimeout(handle);
@@ -83,7 +80,7 @@
        *
        * @memberof Polymer.Async.timeOut
        * @param {Function} fn Callback to run
-       * @param {number} delay Delay in milliseconds
+       * @param {number=} delay Delay in milliseconds
        * @return {number} Handle used for canceling task
        */
       run(fn, delay) {
@@ -112,7 +109,7 @@
        * Enqueues a function called at `requestAnimationFrame` timing.
        *
        * @memberof Polymer.Async.animationFrame
-       * @param {Function} fn Callback to run
+       * @param {function(number)} fn Callback to run
        * @return {number} Handle used for canceling task
        */
       run(fn) {