requestUpdate(name, oldValue) {
        let shouldRequestUpdate = true;
        // if we have a property key, perform property update steps.
        if (name !== undefined && !this._changedProperties.has(name)) {
            const ctor = this.constructor;
            const options = ctor._classProperties.get(name) || defaultPropertyDeclaration;
            if (ctor._valueHasChanged(this[name], oldValue, options.hasChanged)) {
                // track old value when changing.
                this._changedProperties.set(name, oldValue);
                // add to reflecting properties set
                if (options.reflect === true &&
                    !(this._updateState & STATE_IS_REFLECTING_TO_PROPERTY)) {
                    if (this._reflectingProperties === undefined) {
                        this._reflectingProperties = new Map();
                    }
                    this._reflectingProperties.set(name, options);
                }
                // abort the request if the property should not be considered changed.
            }
            else {
                shouldRequestUpdate = false;
            }
        }
        if (!this._hasRequestedUpdate && shouldRequestUpdate) {
            this._enqueueUpdate();
        }
        return this.updateComplete;
    }
Requests an update which is processed asynchronously. This should
be called when an element should update based on some state not triggered
by setting a property. In this case, pass no arguments. It should also be
called when manually implementing a property setter. In this case, pass the
property `name` and `oldValue` to ensure that any configured property
options are honored. Returns the `updateComplete` Promise which is resolved
when the update completes.

@param name {PropertyKey} (optional) name of requesting property
@param oldValue {any} (optional) old value of requesting property
@returns {Promise} A Promise that is resolved when the update completes.