// tslint:disable:variable-name Describing an API that's defined elsewhere.
// tslint:disable:no-any describes the API as best we are able today

import {ElementMixin} from '../mixins/element-mixin.js';

import {GestureEventListeners} from '../mixins/gesture-event-listeners.js';

import {DirMixin} from '../mixins/dir-mixin.js';

import {dedupingMixin} from '../utils/mixin.js';

import {dom, matchesSelector} from './polymer.dom.js';

import {setTouchAction} from '../utils/gestures.js';

import {Debouncer} from '../utils/debounce.js';

import {timeOut, microTask} from '../utils/async.js';

import {get} from '../utils/path.js';

import {scopeSubtree} from '../utils/scope-subtree.js';

import {findObservedAttributesGetter} from '../mixins/disable-upgrade-mixin.js';

import {register} from '../utils/telemetry.js';

export {LegacyElementMixin};


/**
 * Element class mixin that provides Polymer's "legacy" API intended to be
 * backward-compatible to the greatest extent possible with the API
 * found on the Polymer 1.x `Polymer.Base` prototype applied to all elements
 * defined using the `Polymer({...})` function.
 */
declare function LegacyElementMixin<T extends new (...args: any[]) => {}>(base: T): T & LegacyElementMixinConstructor & ElementMixinConstructor & PropertyEffectsConstructor & TemplateStampConstructor & PropertyAccessorsConstructor & PropertiesChangedConstructor & PropertiesMixinConstructor & GestureEventListenersConstructor & DirMixinConstructor;

import {ElementMixinConstructor} from '../mixins/element-mixin.js';

import {PropertyEffectsConstructor, PropertyEffects} from '../mixins/property-effects.js';

import {TemplateStampConstructor, TemplateStamp} from '../mixins/template-stamp.js';

import {PropertyAccessorsConstructor, PropertyAccessors} from '../mixins/property-accessors.js';

import {PropertiesChangedConstructor, PropertiesChanged} from '../mixins/properties-changed.js';

import {PropertiesMixinConstructor, PropertiesMixin} from '../mixins/properties-mixin.js';

import {GestureEventListenersConstructor} from '../mixins/gesture-event-listeners.js';

import {DirMixinConstructor} from '../mixins/dir-mixin.js';

interface LegacyElementMixinConstructor {
  new(...args: any[]): LegacyElementMixin;
}

export {LegacyElementMixinConstructor};

interface LegacyElementMixin extends ElementMixin, PropertyEffects, TemplateStamp, PropertyAccessors, PropertiesChanged, PropertiesMixin, GestureEventListeners, DirMixin {
  isAttached: boolean;
  _debouncers: {[key: string]: Function|null}|null;
  _legacyForceObservedAttributes: boolean|undefined;

  /**
   * Return the element whose local dom within which this element
   * is contained. This is a shorthand for
   * `this.getRootNode().host`.
   */
  readonly domHost: Node|null;
  is: string;

  /**
   * Overrides the default `Polymer.PropertyEffects` implementation to
   * add support for installing `hostAttributes` and `listeners`.
   */
  ready(): void;

  /**
   * Overrides the default `Polymer.PropertyEffects` implementation to
   * add support for class initialization via the `_registered` callback.
   * This is called only when the first instance of the element is created.
   */
  _initializeProperties(): void;
  _enableProperties(): void;

  /**
   * Provides an override implementation of `attributeChangedCallback`
   * which adds the Polymer legacy API's `attributeChanged` method.
   *
   * @param name Name of attribute.
   * @param old Old value of attribute.
   * @param value Current value of attribute.
   * @param namespace Attribute namespace.
   */
  attributeChangedCallback(name: string, old: string|null, value: string|null, namespace: string|null): void;

  /**
   * Provides an implementation of `connectedCallback`
   * which adds Polymer legacy API's `attached` method.
   */
  connectedCallback(): void;

  /**
   * Provides an implementation of `disconnectedCallback`
   * which adds Polymer legacy API's `detached` method.
   */
  disconnectedCallback(): void;
  _canApplyPropertyDefault(property: any): any;

  /**
   * Legacy callback called during the `constructor`, for overriding
   * by the user.
   */
  created(): void;

  /**
   * Sets the value of an attribute.
   * @param name The name of the attribute to change.
   * @param value The new attribute value.
   */
  setAttribute(name: string, value: string): void;

  /**
   * Removes an attribute.
   *
   * @param name The name of the attribute to remove.
   */
  removeAttribute(name: string): void;

  /**
   * Legacy callback called during `connectedCallback`, for overriding
   * by the user.
   */
  attached(): void;

  /**
   * Legacy callback called during `disconnectedCallback`, for overriding
   * by the user.
   */
  detached(): void;

  /**
   * Legacy callback called during `attributeChangedChallback`, for overriding
   * by the user.
   *
   * @param name Name of attribute.
   * @param old Old value of attribute.
   * @param value Current value of attribute.
   */
  attributeChanged(name: string, old: string|null, value: string|null): void;
  _takeAttributes(): void;

  /**
   * Called automatically when an element is initializing.
   * Users may override this method to perform class registration time
   * work. The implementation should ensure the work is performed
   * only once for the class.
   */
  _registered(): void;

  /**
   * Ensures an element has required attributes. Called when the element
   * is being readied via `ready`. Users should override to set the
   * element's required attributes. The implementation should be sure
   * to check and not override existing attributes added by
   * the user of the element. Typically, setting attributes should be left
   * to the element user and not done here; reasonable exceptions include
   * setting aria roles and focusability.
   */
  _ensureAttributes(): void;

  /**
   * Adds element event listeners. Called when the element
   * is being readied via `ready`. Users should override to
   * add any required element event listeners.
   * In performance critical elements, the work done here should be kept
   * to a minimum since it is done before the element is rendered. In
   * these elements, consider adding listeners asynchronously so as not to
   * block render.
   */
  _applyListeners(): void;

  /**
   * Converts a typed JavaScript value to a string.
   *
   * Note this method is provided as backward-compatible legacy API
   * only.  It is not directly called by any Polymer features. To customize
   * how properties are serialized to attributes for attribute bindings and
   * `reflectToAttribute: true` properties as well as this method, override
   * the `_serializeValue` method provided by `Polymer.PropertyAccessors`.
   *
   * @param value Value to deserialize
   * @returns Serialized value
   */
  serialize(value: any): string|undefined;

  /**
   * Converts a string to a typed JavaScript value.
   *
   * Note this method is provided as backward-compatible legacy API
   * only.  It is not directly called by any Polymer features.  To customize
   * how attributes are deserialized to properties for in
   * `attributeChangedCallback`, override `_deserializeValue` method
   * provided by `Polymer.PropertyAccessors`.
   *
   * @param value String to deserialize
   * @param type Type to deserialize the string to
   * @returns Returns the deserialized value in the `type` given.
   */
  deserialize(value: string, type: any): any;

  /**
   * Serializes a property to its associated attribute.
   *
   * Note this method is provided as backward-compatible legacy API
   * only.  It is not directly called by any Polymer features.
   *
   * @param property Property name to reflect.
   * @param attribute Attribute name to reflect.
   * @param value Property value to reflect.
   */
  reflectPropertyToAttribute(property: string, attribute?: string, value?: any): void;

  /**
   * Sets a typed value to an HTML attribute on a node.
   *
   * Note this method is provided as backward-compatible legacy API
   * only.  It is not directly called by any Polymer features.
   *
   * @param value Value to serialize.
   * @param attribute Attribute name to serialize to.
   * @param node Element to set attribute to.
   */
  serializeValueToAttribute(value: any, attribute: string, node: Element|null): void;

  /**
   * Copies own properties (including accessor descriptors) from a source
   * object to a target object.
   *
   * @param prototype Target object to copy properties to.
   * @param api Source object to copy properties from.
   * @returns prototype object that was passed as first argument.
   */
  extend(prototype: object|null, api: object|null): object|null;

  /**
   * Copies props from a source object to a target object.
   *
   * Note, this method uses a simple `for...in` strategy for enumerating
   * properties.  To ensure only `ownProperties` are copied from source
   * to target and that accessor implementations are copied, use `extend`.
   *
   * @param target Target object to copy properties to.
   * @param source Source object to copy properties from.
   * @returns Target object that was passed as first argument.
   */
  mixin(target: object, source: object): object;

  /**
   * Sets the prototype of an object.
   *
   * Note this method is provided as backward-compatible legacy API
   * only.  It is not directly called by any Polymer features.
   *
   * @param object The object on which to set the prototype.
   * @param prototype The prototype that will be set on the given
   * `object`.
   * @returns Returns the given `object` with its prototype set
   * to the given `prototype` object.
   */
  chainObject(object: object|null, prototype: object|null): object|null;

  /**
   * Calls `importNode` on the `content` of the `template` specified and
   * returns a document fragment containing the imported content.
   *
   * @param template HTML template element to instance.
   * @returns Document fragment containing the imported
   *   template content.
   */
  instanceTemplate(template: HTMLTemplateElement|null): DocumentFragment;

  /**
   * Dispatches a custom event with an optional detail value.
   *
   * @param type Name of event type.
   * @param detail Detail value containing event-specific
   *   payload.
   * @param options Object specifying options.  These may include:
   *  `bubbles` (boolean, defaults to `true`),
   *  `cancelable` (boolean, defaults to false), and
   *  `node` on which to fire the event (HTMLElement, defaults to `this`).
   * @returns The new event that was fired.
   */
  fire(type: string, detail?: any, options?: {bubbles?: boolean, cancelable?: boolean, composed?: boolean}): Event;

  /**
   * Convenience method to add an event listener on a given element,
   * late bound to a named method on this element.
   *
   * @param node Element to add event listener to.
   * @param eventName Name of event to listen for.
   * @param methodName Name of handler method on `this` to call.
   */
  listen(node: EventTarget|null, eventName: string, methodName: string): void;

  /**
   * Convenience method to remove an event listener from a given element,
   * late bound to a named method on this element.
   *
   * @param node Element to remove event listener from.
   * @param eventName Name of event to stop listening to.
   * @param methodName Name of handler method on `this` to not call
   *      anymore.
   */
  unlisten(node: EventTarget|null, eventName: string, methodName: string): void;

  /**
   * Override scrolling behavior to all direction, one direction, or none.
   *
   * Valid scroll directions:
   *   - 'all': scroll in any direction
   *   - 'x': scroll only in the 'x' direction
   *   - 'y': scroll only in the 'y' direction
   *   - 'none': disable scrolling for this node
   *
   * @param direction Direction to allow scrolling
   * Defaults to `all`.
   * @param node Element to apply scroll direction setting.
   * Defaults to `this`.
   */
  setScrollDirection(direction?: string, node?: Element|null): void;

  /**
   * Convenience method to run `querySelector` on this local DOM scope.
   *
   * This function calls `Polymer.dom(this.root).querySelector(slctr)`.
   *
   * @param slctr Selector to run on this local DOM scope
   * @returns Element found by the selector, or null if not found.
   */
  $$(slctr: string): Element|null;

  /**
   * Force this element to distribute its children to its local dom.
   * This should not be necessary as of Polymer 2.0.2 and is provided only
   * for backwards compatibility.
   */
  distributeContent(): void;

  /**
   * Returns a list of nodes that are the effective childNodes. The effective
   * childNodes list is the same as the element's childNodes except that
   * any `<content>` elements are replaced with the list of nodes distributed
   * to the `<content>`, the result of its `getDistributedNodes` method.
   *
   * @returns List of effective child nodes.
   */
  getEffectiveChildNodes(): Node[];

  /**
   * Returns a list of nodes distributed within this element that match
   * `selector`. These can be dom children or elements distributed to
   * children that are insertion points.
   *
   * @param selector Selector to run.
   * @returns List of distributed elements that match selector.
   */
  queryDistributedElements(selector: string): Node[];

  /**
   * Returns a list of elements that are the effective children. The effective
   * children list is the same as the element's children except that
   * any `<content>` elements are replaced with the list of elements
   * distributed to the `<content>`.
   *
   * @returns List of effective children.
   */
  getEffectiveChildren(): Node[];

  /**
   * Returns a string of text content that is the concatenation of the
   * text content's of the element's effective childNodes (the elements
   * returned by <a href="#getEffectiveChildNodes>getEffectiveChildNodes</a>.
   *
   * @returns List of effective children.
   */
  getEffectiveTextContent(): string;

  /**
   * Returns the first effective childNode within this element that
   * match `selector`. These can be dom child nodes or elements distributed
   * to children that are insertion points.
   *
   * @param selector Selector to run.
   * @returns First effective child node that matches selector.
   */
  queryEffectiveChildren(selector: string): Node|null;

  /**
   * Returns a list of effective childNodes within this element that
   * match `selector`. These can be dom child nodes or elements distributed
   * to children that are insertion points.
   *
   * @param selector Selector to run.
   * @returns List of effective child nodes that match
   *     selector.
   */
  queryAllEffectiveChildren(selector: string): Node[];

  /**
   * Returns a list of nodes distributed to this element's `<slot>`.
   *
   * If this element contains more than one `<slot>` in its local DOM,
   * an optional selector may be passed to choose the desired content.
   *
   * @param slctr CSS selector to choose the desired
   *   `<slot>`.  Defaults to `content`.
   * @returns List of distributed nodes for the `<slot>`.
   */
  getContentChildNodes(slctr?: string): Node[];

  /**
   * Returns a list of element children distributed to this element's
   * `<slot>`.
   *
   * If this element contains more than one `<slot>` in its
   * local DOM, an optional selector may be passed to choose the desired
   * content.  This method differs from `getContentChildNodes` in that only
   * elements are returned.
   *
   * @param slctr CSS selector to choose the desired
   *   `<content>`.  Defaults to `content`.
   * @returns List of distributed nodes for the
   *   `<slot>`.
   */
  getContentChildren(slctr?: string): HTMLElement[];

  /**
   * Checks whether an element is in this element's light DOM tree.
   *
   * @param node The element to be checked.
   * @returns true if node is in this element's light DOM tree.
   */
  isLightDescendant(node: Node|null): boolean;

  /**
   * Checks whether an element is in this element's local DOM tree.
   *
   * @param node The element to be checked.
   * @returns true if node is in this element's local DOM tree.
   */
  isLocalDescendant(node: Element): boolean;

  /**
   * No-op for backwards compatibility. This should now be handled by
   * ShadyCss library.
   *
   * @param container Container element to scope
   * @param shouldObserve if true, start a mutation observer for added nodes to the container
   * @returns Returns a new MutationObserver on `container` if `shouldObserve` is true.
   */
  scopeSubtree(container: Element, shouldObserve?: boolean): MutationObserver|null;

  /**
   * Returns the computed style value for the given property.
   *
   * @param property The css property name.
   * @returns Returns the computed css property value for the given
   * `property`.
   */
  getComputedStyleValue(property: string): string;

  /**
   * Call `debounce` to collapse multiple requests for a named task into
   * one invocation which is made after the wait time has elapsed with
   * no new request.  If no wait time is given, the callback will be called
   * at microtask timing (guaranteed before paint).
   *
   *     debouncedClickAction(e) {
   *       // will not call `processClick` more than once per 100ms
   *       this.debounce('click', function() {
   *        this.processClick();
   *       } 100);
   *     }
   *
   * @param jobName String to identify the debounce job.
   * @param callback Function that is called (with `this`
   *   context) when the wait time elapses.
   * @param wait Optional wait time in milliseconds (ms) after the
   *   last signal that must elapse before invoking `callback`
   * @returns Returns a debouncer object on which exists the
   * following methods: `isActive()` returns true if the debouncer is
   * active; `cancel()` cancels the debouncer if it is active;
   * `flush()` immediately invokes the debounced callback if the debouncer
   * is active.
   */
  debounce(jobName: string, callback: () => void, wait?: number): object;

  /**
   * Returns whether a named debouncer is active.
   *
   * @param jobName The name of the debouncer started with `debounce`
   * @returns Whether the debouncer is active (has not yet fired).
   */
  isDebouncerActive(jobName: string): boolean;

  /**
   * Immediately calls the debouncer `callback` and inactivates it.
   *
   * @param jobName The name of the debouncer started with `debounce`
   */
  flushDebouncer(jobName: string): void;

  /**
   * Cancels an active debouncer.  The `callback` will not be called.
   *
   * @param jobName The name of the debouncer started with `debounce`
   */
  cancelDebouncer(jobName: string): void;

  /**
   * Runs a callback function asynchronously.
   *
   * By default (if no waitTime is specified), async callbacks are run at
   * microtask timing, which will occur before paint.
   *
   * @param callback The callback function to run, bound to
   *     `this`.
   * @param waitTime Time to wait before calling the
   *   `callback`.  If unspecified or 0, the callback will be run at microtask
   *   timing (before paint).
   * @returns Handle that may be used to cancel the async job.
   */
  async(callback: Function, waitTime?: number): number;

  /**
   * Cancels an async operation started with `async`.
   *
   * @param handle Handle returned from original `async` call to
   *   cancel.
   */
  cancelAsync(handle: number): void;

  /**
   * Convenience method for creating an element and configuring it.
   *
   * @param tag HTML element tag to create.
   * @param props Object of properties to configure on the
   *    instance.
   * @returns Newly created and configured element.
   */
  create(tag: string, props?: object|null): Element;

  /**
   * Polyfill for Element.prototype.matches, which is sometimes still
   * prefixed.
   *
   * @param selector Selector to test.
   * @param node Element to test the selector against.
   * @returns Whether the element matches the selector.
   */
  elementMatches(selector: string, node?: Element): boolean;

  /**
   * Toggles an HTML attribute on or off.
   *
   * @param name HTML attribute name
   * @param bool Boolean to force the attribute on or off.
   *    When unspecified, the state of the attribute will be reversed.
   * @returns true if the attribute now exists
   */
  toggleAttribute(name: string, bool?: boolean): boolean;

  /**
   * Toggles a CSS class on or off.
   *
   * @param name CSS class name
   * @param bool Boolean to force the class on or off.
   *    When unspecified, the state of the class will be reversed.
   * @param node Node to target.  Defaults to `this`.
   */
  toggleClass(name: string, bool?: boolean, node?: Element|null): void;

  /**
   * Cross-platform helper for setting an element's CSS `transform` property.
   *
   * @param transformText Transform setting.
   * @param node Element to apply the transform to.
   * Defaults to `this`
   */
  transform(transformText: string, node?: Element|null): void;

  /**
   * Cross-platform helper for setting an element's CSS `translate3d`
   * property.
   *
   * @param x X offset.
   * @param y Y offset.
   * @param z Z offset.
   * @param node Element to apply the transform to.
   * Defaults to `this`.
   */
  translate3d(x: number|string, y: number|string, z: number|string, node?: Element|null): void;

  /**
   * Removes an item from an array, if it exists.
   *
   * If the array is specified by path, a change notification is
   * generated, so that observers, data bindings and computed
   * properties watching that path can update.
   *
   * If the array is passed directly, **no change
   * notification is generated**.
   *
   * @param arrayOrPath Path to array from
   *     which to remove the item
   *   (or the array itself).
   * @param item Item to remove.
   * @returns Array containing item removed.
   */
  arrayDelete(arrayOrPath: string|Array<number|string>, item: any): any[]|null;

  /**
   * Facades `console.log`/`warn`/`error` as override point.
   *
   * @param level One of 'log', 'warn', 'error'
   * @param args Array of strings or objects to log
   */
  _logger(level: string, args: any[]|null): void;

  /**
   * Facades `console.log` as an override point.
   *
   * @param args Array of strings or objects to log
   */
  _log(...args: any[]): void;

  /**
   * Facades `console.warn` as an override point.
   *
   * @param args Array of strings or objects to log
   */
  _warn(...args: any[]): void;

  /**
   * Facades `console.error` as an override point.
   *
   * @param args Array of strings or objects to log
   */
  _error(...args: any[]): void;

  /**
   * Formats a message using the element type an a method name.
   *
   * @param methodName Method name to associate with message
   * @param args Array of strings or objects to log
   * @returns Array with formatting information for `console`
   *   logging.
   */
  _logf(methodName: string, ...args: any[]): any[];
}