import './stencil.core';
/**
 * This is an autogenerated file created by the Stencil build process.
 * It contains typing information for all components that exist in this project
 * and imports for stencil collections that might be configured in your stencil.config.js file
 */

import './stencil.core';

declare global {
  namespace JSX {
    interface Element {}
    export interface IntrinsicElements {}
  }
  namespace JSXElements {}

  interface HTMLElement {
    componentOnReady?: () => Promise<this | null>;
  }

  interface HTMLStencilElement extends HTMLElement {
    componentOnReady(): Promise<this>;

    forceUpdate(): void;
  }

  interface HTMLAttributes {}
}

import '@stencil/router';
import '@stencil/state-tunnel';

import {
  MatchResults,
  RouterHistory,
} from '@stencil/router';
import {
  IEmaTabContentData,
  IEmaTabHeaderData,
} from './components/tabs/interfaces';

declare global {

  namespace StencilComponents {
    interface EmaAppComponents {
      'history': RouterHistory;
      'match': MatchResults;
      'tag': string;
      'tags': any[];
    }
  }

  interface HTMLEmaAppComponentsElement extends StencilComponents.EmaAppComponents, HTMLStencilElement {}

  var HTMLEmaAppComponentsElement: {
    prototype: HTMLEmaAppComponentsElement;
    new (): HTMLEmaAppComponentsElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-components': HTMLEmaAppComponentsElement;
  }
  interface ElementTagNameMap {
    'ema-app-components': HTMLEmaAppComponentsElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-components': JSXElements.EmaAppComponentsAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppComponentsAttributes extends HTMLAttributes {
      'history'?: RouterHistory;
      'match'?: MatchResults;
      'tag'?: string;
      'tags'?: any[];
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppDev {
      'clientId': string;
    }
  }

  interface HTMLEmaAppDevElement extends StencilComponents.EmaAppDev, HTMLStencilElement {}

  var HTMLEmaAppDevElement: {
    prototype: HTMLEmaAppDevElement;
    new (): HTMLEmaAppDevElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-dev': HTMLEmaAppDevElement;
  }
  interface ElementTagNameMap {
    'ema-app-dev': HTMLEmaAppDevElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-dev': JSXElements.EmaAppDevAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppDevAttributes extends HTMLAttributes {
      'clientId'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppDrupal {
      'configJson': any;
      'match': MatchResults;
    }
  }

  interface HTMLEmaAppDrupalElement extends StencilComponents.EmaAppDrupal, HTMLStencilElement {}

  var HTMLEmaAppDrupalElement: {
    prototype: HTMLEmaAppDrupalElement;
    new (): HTMLEmaAppDrupalElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-drupal': HTMLEmaAppDrupalElement;
  }
  interface ElementTagNameMap {
    'ema-app-drupal': HTMLEmaAppDrupalElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-drupal': JSXElements.EmaAppDrupalAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppDrupalAttributes extends HTMLAttributes {
      'configJson'?: any;
      'match'?: MatchResults;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppForms {

    }
  }

  interface HTMLEmaAppFormsElement extends StencilComponents.EmaAppForms, HTMLStencilElement {}

  var HTMLEmaAppFormsElement: {
    prototype: HTMLEmaAppFormsElement;
    new (): HTMLEmaAppFormsElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-forms': HTMLEmaAppFormsElement;
  }
  interface ElementTagNameMap {
    'ema-app-forms': HTMLEmaAppFormsElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-forms': JSXElements.EmaAppFormsAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppFormsAttributes extends HTMLAttributes {

    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppHome {

    }
  }

  interface HTMLEmaAppHomeElement extends StencilComponents.EmaAppHome, HTMLStencilElement {}

  var HTMLEmaAppHomeElement: {
    prototype: HTMLEmaAppHomeElement;
    new (): HTMLEmaAppHomeElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-home': HTMLEmaAppHomeElement;
  }
  interface ElementTagNameMap {
    'ema-app-home': HTMLEmaAppHomeElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-home': JSXElements.EmaAppHomeAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppHomeAttributes extends HTMLAttributes {

    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppIframe {
      'iframeUrl': string;
      'match': MatchResults;
      'queryParams': string;
    }
  }

  interface HTMLEmaAppIframeElement extends StencilComponents.EmaAppIframe, HTMLStencilElement {}

  var HTMLEmaAppIframeElement: {
    prototype: HTMLEmaAppIframeElement;
    new (): HTMLEmaAppIframeElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-iframe': HTMLEmaAppIframeElement;
  }
  interface ElementTagNameMap {
    'ema-app-iframe': HTMLEmaAppIframeElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-iframe': JSXElements.EmaAppIframeAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppIframeAttributes extends HTMLAttributes {
      'iframeUrl'?: string;
      'match'?: MatchResults;
      'queryParams'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppRoot {
      'baseUrl': string;
    }
  }

  interface HTMLEmaAppRootElement extends StencilComponents.EmaAppRoot, HTMLStencilElement {}

  var HTMLEmaAppRootElement: {
    prototype: HTMLEmaAppRootElement;
    new (): HTMLEmaAppRootElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-root': HTMLEmaAppRootElement;
  }
  interface ElementTagNameMap {
    'ema-app-root': HTMLEmaAppRootElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-root': JSXElements.EmaAppRootAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppRootAttributes extends HTMLAttributes {
      'baseUrl'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppSketch {
      'dataJson': string;
    }
  }

  interface HTMLEmaAppSketchElement extends StencilComponents.EmaAppSketch, HTMLStencilElement {}

  var HTMLEmaAppSketchElement: {
    prototype: HTMLEmaAppSketchElement;
    new (): HTMLEmaAppSketchElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-sketch': HTMLEmaAppSketchElement;
  }
  interface ElementTagNameMap {
    'ema-app-sketch': HTMLEmaAppSketchElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-sketch': JSXElements.EmaAppSketchAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppSketchAttributes extends HTMLAttributes {
      'dataJson'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppSwagger {
      'match': MatchResults;
    }
  }

  interface HTMLEmaAppSwaggerElement extends StencilComponents.EmaAppSwagger, HTMLStencilElement {}

  var HTMLEmaAppSwaggerElement: {
    prototype: HTMLEmaAppSwaggerElement;
    new (): HTMLEmaAppSwaggerElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-swagger': HTMLEmaAppSwaggerElement;
  }
  interface ElementTagNameMap {
    'ema-app-swagger': HTMLEmaAppSwaggerElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-swagger': JSXElements.EmaAppSwaggerAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppSwaggerAttributes extends HTMLAttributes {
      'match'?: MatchResults;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaAppWordpress {
      'match': MatchResults;
    }
  }

  interface HTMLEmaAppWordpressElement extends StencilComponents.EmaAppWordpress, HTMLStencilElement {}

  var HTMLEmaAppWordpressElement: {
    prototype: HTMLEmaAppWordpressElement;
    new (): HTMLEmaAppWordpressElement;
  };
  interface HTMLElementTagNameMap {
    'ema-app-wordpress': HTMLEmaAppWordpressElement;
  }
  interface ElementTagNameMap {
    'ema-app-wordpress': HTMLEmaAppWordpressElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-app-wordpress': JSXElements.EmaAppWordpressAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaAppWordpressAttributes extends HTMLAttributes {
      'match'?: MatchResults;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface SkAbout {
      'dataJson': string;
      'getElements': () => any[];
      'hide': (duration?: number, delay?: number, visible?: boolean) => void;
      'redraw': boolean;
      'setData': (data: any) => void;
      'show': (duration?: number, delay?: number, display?: string) => void;
      'visible': boolean;
    }
  }

  interface HTMLSkAboutElement extends StencilComponents.SkAbout, HTMLStencilElement {}

  var HTMLSkAboutElement: {
    prototype: HTMLSkAboutElement;
    new (): HTMLSkAboutElement;
  };
  interface HTMLElementTagNameMap {
    'sk-about': HTMLSkAboutElement;
  }
  interface ElementTagNameMap {
    'sk-about': HTMLSkAboutElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'sk-about': JSXElements.SkAboutAttributes;
    }
  }
  namespace JSXElements {
    export interface SkAboutAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'onSvgElementClick'?: (event: CustomEvent) => void;
      'redraw'?: boolean;
      'visible'?: boolean;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface SkDevStack {
      'dataJson': string;
      'getElements': () => any[];
      'hide': (duration?: number, delay?: number, visible?: boolean) => void;
      'redraw': boolean;
      'setData': (data: any) => void;
      'show': (duration?: number, delay?: number, display?: string) => void;
      'visible': boolean;
    }
  }

  interface HTMLSkDevStackElement extends StencilComponents.SkDevStack, HTMLStencilElement {}

  var HTMLSkDevStackElement: {
    prototype: HTMLSkDevStackElement;
    new (): HTMLSkDevStackElement;
  };
  interface HTMLElementTagNameMap {
    'sk-dev-stack': HTMLSkDevStackElement;
  }
  interface ElementTagNameMap {
    'sk-dev-stack': HTMLSkDevStackElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'sk-dev-stack': JSXElements.SkDevStackAttributes;
    }
  }
  namespace JSXElements {
    export interface SkDevStackAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'onSvgElementClick'?: (event: CustomEvent) => void;
      'redraw'?: boolean;
      'visible'?: boolean;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface SkGraph {
      'dataJson': string;
      'getElements': () => any[];
      'hide': (duration?: number, delay?: number, visible?: boolean) => void;
      'redraw': boolean;
      'setData': (data: any) => void;
      'show': (duration?: number, delay?: number, display?: string) => void;
      'visible': boolean;
    }
  }

  interface HTMLSkGraphElement extends StencilComponents.SkGraph, HTMLStencilElement {}

  var HTMLSkGraphElement: {
    prototype: HTMLSkGraphElement;
    new (): HTMLSkGraphElement;
  };
  interface HTMLElementTagNameMap {
    'sk-graph': HTMLSkGraphElement;
  }
  interface ElementTagNameMap {
    'sk-graph': HTMLSkGraphElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'sk-graph': JSXElements.SkGraphAttributes;
    }
  }
  namespace JSXElements {
    export interface SkGraphAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'onSvgElementClick'?: (event: CustomEvent) => void;
      'redraw'?: boolean;
      'visible'?: boolean;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface SkIconLogo {
      'dataJson': string;
      'getElements': () => any[];
      'hide': (duration?: number, delay?: number, visible?: boolean) => void;
      'redraw': boolean;
      'setData': (data: any) => void;
      'show': (duration?: number, delay?: number, display?: string) => void;
      'visible': boolean;
    }
  }

  interface HTMLSkIconLogoElement extends StencilComponents.SkIconLogo, HTMLStencilElement {}

  var HTMLSkIconLogoElement: {
    prototype: HTMLSkIconLogoElement;
    new (): HTMLSkIconLogoElement;
  };
  interface HTMLElementTagNameMap {
    'sk-icon-logo': HTMLSkIconLogoElement;
  }
  interface ElementTagNameMap {
    'sk-icon-logo': HTMLSkIconLogoElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'sk-icon-logo': JSXElements.SkIconLogoAttributes;
    }
  }
  namespace JSXElements {
    export interface SkIconLogoAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'onSvgElementClick'?: (event: CustomEvent) => void;
      'redraw'?: boolean;
      'visible'?: boolean;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface SkSketch {
      'dataJson': any;
    }
  }

  interface HTMLSkSketchElement extends StencilComponents.SkSketch, HTMLStencilElement {}

  var HTMLSkSketchElement: {
    prototype: HTMLSkSketchElement;
    new (): HTMLSkSketchElement;
  };
  interface HTMLElementTagNameMap {
    'sk-sketch': HTMLSkSketchElement;
  }
  interface ElementTagNameMap {
    'sk-sketch': HTMLSkSketchElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'sk-sketch': JSXElements.SkSketchAttributes;
    }
  }
  namespace JSXElements {
    export interface SkSketchAttributes extends HTMLAttributes {
      'dataJson'?: any;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface SkSplash {
      'dataJson': string;
      'getElements': () => any[];
      'hide': (duration?: number, delay?: number, visible?: boolean) => void;
      'redraw': boolean;
      'setData': (data: any) => void;
      'show': (duration?: number, delay?: number, display?: string) => void;
      'visible': boolean;
    }
  }

  interface HTMLSkSplashElement extends StencilComponents.SkSplash, HTMLStencilElement {}

  var HTMLSkSplashElement: {
    prototype: HTMLSkSplashElement;
    new (): HTMLSkSplashElement;
  };
  interface HTMLElementTagNameMap {
    'sk-splash': HTMLSkSplashElement;
  }
  interface ElementTagNameMap {
    'sk-splash': HTMLSkSplashElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'sk-splash': JSXElements.SkSplashAttributes;
    }
  }
  namespace JSXElements {
    export interface SkSplashAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'onSvgElementClick'?: (event: CustomEvent) => void;
      'redraw'?: boolean;
      'visible'?: boolean;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaCardBottom {

    }
  }

  interface HTMLEmaCardBottomElement extends StencilComponents.EmaCardBottom, HTMLStencilElement {}

  var HTMLEmaCardBottomElement: {
    prototype: HTMLEmaCardBottomElement;
    new (): HTMLEmaCardBottomElement;
  };
  interface HTMLElementTagNameMap {
    'ema-card-bottom': HTMLEmaCardBottomElement;
  }
  interface ElementTagNameMap {
    'ema-card-bottom': HTMLEmaCardBottomElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-card-bottom': JSXElements.EmaCardBottomAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaCardBottomAttributes extends HTMLAttributes {

    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaCardContent {

    }
  }

  interface HTMLEmaCardContentElement extends StencilComponents.EmaCardContent, HTMLStencilElement {}

  var HTMLEmaCardContentElement: {
    prototype: HTMLEmaCardContentElement;
    new (): HTMLEmaCardContentElement;
  };
  interface HTMLElementTagNameMap {
    'ema-card-content': HTMLEmaCardContentElement;
  }
  interface ElementTagNameMap {
    'ema-card-content': HTMLEmaCardContentElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-card-content': JSXElements.EmaCardContentAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaCardContentAttributes extends HTMLAttributes {

    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaCardHeader {

    }
  }

  interface HTMLEmaCardHeaderElement extends StencilComponents.EmaCardHeader, HTMLStencilElement {}

  var HTMLEmaCardHeaderElement: {
    prototype: HTMLEmaCardHeaderElement;
    new (): HTMLEmaCardHeaderElement;
  };
  interface HTMLElementTagNameMap {
    'ema-card-header': HTMLEmaCardHeaderElement;
  }
  interface ElementTagNameMap {
    'ema-card-header': HTMLEmaCardHeaderElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-card-header': JSXElements.EmaCardHeaderAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaCardHeaderAttributes extends HTMLAttributes {

    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaCard {

    }
  }

  interface HTMLEmaCardElement extends StencilComponents.EmaCard, HTMLStencilElement {}

  var HTMLEmaCardElement: {
    prototype: HTMLEmaCardElement;
    new (): HTMLEmaCardElement;
  };
  interface HTMLElementTagNameMap {
    'ema-card': HTMLEmaCardElement;
  }
  interface ElementTagNameMap {
    'ema-card': HTMLEmaCardElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-card': JSXElements.EmaCardAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaCardAttributes extends HTMLAttributes {

    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaCollapsible {
      'collapsed': boolean;
      'label': string;
    }
  }

  interface HTMLEmaCollapsibleElement extends StencilComponents.EmaCollapsible, HTMLStencilElement {}

  var HTMLEmaCollapsibleElement: {
    prototype: HTMLEmaCollapsibleElement;
    new (): HTMLEmaCollapsibleElement;
  };
  interface HTMLElementTagNameMap {
    'ema-collapsible': HTMLEmaCollapsibleElement;
  }
  interface ElementTagNameMap {
    'ema-collapsible': HTMLEmaCollapsibleElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-collapsible': JSXElements.EmaCollapsibleAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaCollapsibleAttributes extends HTMLAttributes {
      'collapsed'?: boolean;
      'label'?: string;
      'onOnToggle'?: (event: CustomEvent) => void;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaDebugger {
      'apiUrl': string;
      'close': () => void;
      'collapseAt': number;
      'dataJson': string;
      'historySize': number;
      'jsonUrl': string;
      'maxLevel': number;
      'open': () => void;
      'pause': () => void;
      'run': () => void;
      'toggle': () => void;
      'type': string;
    }
  }

  interface HTMLEmaDebuggerElement extends StencilComponents.EmaDebugger, HTMLStencilElement {}

  var HTMLEmaDebuggerElement: {
    prototype: HTMLEmaDebuggerElement;
    new (): HTMLEmaDebuggerElement;
  };
  interface HTMLElementTagNameMap {
    'ema-debugger': HTMLEmaDebuggerElement;
  }
  interface ElementTagNameMap {
    'ema-debugger': HTMLEmaDebuggerElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-debugger': JSXElements.EmaDebuggerAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaDebuggerAttributes extends HTMLAttributes {
      'apiUrl'?: string;
      'collapseAt'?: number;
      'dataJson'?: string;
      'historySize'?: number;
      'jsonUrl'?: string;
      'maxLevel'?: number;
      'type'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaDemo {
      'tag': string;
    }
  }

  interface HTMLEmaDemoElement extends StencilComponents.EmaDemo, HTMLStencilElement {}

  var HTMLEmaDemoElement: {
    prototype: HTMLEmaDemoElement;
    new (): HTMLEmaDemoElement;
  };
  interface HTMLElementTagNameMap {
    'ema-demo': HTMLEmaDemoElement;
  }
  interface ElementTagNameMap {
    'ema-demo': HTMLEmaDemoElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-demo': JSXElements.EmaDemoAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaDemoAttributes extends HTMLAttributes {
      'tag'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaDialog {
      'alert': (msg?: string, options?: {}) => void;
      'allowClose': boolean;
      'cancelLabel': string;
      'confirm': (msg?: string, calllback?: () => void, options?: {}) => void;
      'confirmLabel': string;
      'continueLabel': string;
      'notice': (msg?: string, options?: {}) => void;
      'popup': (options?: {}) => void;
      'setConfirmHandler': (callBackHandler: any) => void;
    }
  }

  interface HTMLEmaDialogElement extends StencilComponents.EmaDialog, HTMLStencilElement {}

  var HTMLEmaDialogElement: {
    prototype: HTMLEmaDialogElement;
    new (): HTMLEmaDialogElement;
  };
  interface HTMLElementTagNameMap {
    'ema-dialog': HTMLEmaDialogElement;
  }
  interface ElementTagNameMap {
    'ema-dialog': HTMLEmaDialogElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-dialog': JSXElements.EmaDialogAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaDialogAttributes extends HTMLAttributes {
      'allowClose'?: boolean;
      'cancelLabel'?: string;
      'confirmLabel'?: string;
      'continueLabel'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaDrupalNode {
      'dataJson': string;
    }
  }

  interface HTMLEmaDrupalNodeElement extends StencilComponents.EmaDrupalNode, HTMLStencilElement {}

  var HTMLEmaDrupalNodeElement: {
    prototype: HTMLEmaDrupalNodeElement;
    new (): HTMLEmaDrupalNodeElement;
  };
  interface HTMLElementTagNameMap {
    'ema-drupal-node': HTMLEmaDrupalNodeElement;
  }
  interface ElementTagNameMap {
    'ema-drupal-node': HTMLEmaDrupalNodeElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-drupal-node': JSXElements.EmaDrupalNodeAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaDrupalNodeAttributes extends HTMLAttributes {
      'dataJson'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaFlashMessage {
      'show': (message: string, activeClass: string, duration?: number) => void;
    }
  }

  interface HTMLEmaFlashMessageElement extends StencilComponents.EmaFlashMessage, HTMLStencilElement {}

  var HTMLEmaFlashMessageElement: {
    prototype: HTMLEmaFlashMessageElement;
    new (): HTMLEmaFlashMessageElement;
  };
  interface HTMLElementTagNameMap {
    'ema-flash-message': HTMLEmaFlashMessageElement;
  }
  interface ElementTagNameMap {
    'ema-flash-message': HTMLEmaFlashMessageElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-flash-message': JSXElements.EmaFlashMessageAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaFlashMessageAttributes extends HTMLAttributes {

    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaFlip {
      'flip': () => void;
      'flipBackEvents': string;
      'flipDuration': number;
      'flipEvents': string;
      'flipTimingFunction': string;
      'isFlipped': boolean;
    }
  }

  interface HTMLEmaFlipElement extends StencilComponents.EmaFlip, HTMLStencilElement {}

  var HTMLEmaFlipElement: {
    prototype: HTMLEmaFlipElement;
    new (): HTMLEmaFlipElement;
  };
  interface HTMLElementTagNameMap {
    'ema-flip': HTMLEmaFlipElement;
  }
  interface ElementTagNameMap {
    'ema-flip': HTMLEmaFlipElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-flip': JSXElements.EmaFlipAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaFlipAttributes extends HTMLAttributes {
      'flipBackEvents'?: string;
      'flipDuration'?: number;
      'flipEvents'?: string;
      'flipTimingFunction'?: string;
      'isFlipped'?: boolean;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaEntityForm {
      'dataJson': string;
      'definitionsJson': string;
      'language': string;
    }
  }

  interface HTMLEmaEntityFormElement extends StencilComponents.EmaEntityForm, HTMLStencilElement {}

  var HTMLEmaEntityFormElement: {
    prototype: HTMLEmaEntityFormElement;
    new (): HTMLEmaEntityFormElement;
  };
  interface HTMLElementTagNameMap {
    'ema-entity-form': HTMLEmaEntityFormElement;
  }
  interface ElementTagNameMap {
    'ema-entity-form': HTMLEmaEntityFormElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-entity-form': JSXElements.EmaEntityFormAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaEntityFormAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'definitionsJson'?: string;
      'language'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaForm {
      'action': string;
      'dataJson': string;
      'dataType': string;
      'definitionsJson': string;
      'formClass': string;
      'language': string;
      'method': string;
      'resettable': boolean;
      'setConstraints': (constraints: any) => void;
      'setDefinitions': (definitions: any) => void;
      'setEntity': (entity: any) => void;
      'setSubmitInterceptor': (submitFn: any) => void;
      'setTranslateService': (instance: any) => void;
      'submitError': string;
      'submitLabel': string;
      'update': () => void;
    }
  }

  interface HTMLEmaFormElement extends StencilComponents.EmaForm, HTMLStencilElement {}

  var HTMLEmaFormElement: {
    prototype: HTMLEmaFormElement;
    new (): HTMLEmaFormElement;
  };
  interface HTMLElementTagNameMap {
    'ema-form': HTMLEmaFormElement;
  }
  interface ElementTagNameMap {
    'ema-form': HTMLEmaFormElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-form': JSXElements.EmaFormAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaFormAttributes extends HTMLAttributes {
      'action'?: string;
      'dataJson'?: string;
      'dataType'?: string;
      'definitionsJson'?: string;
      'formClass'?: string;
      'language'?: string;
      'method'?: string;
      'onFormSubmitSucces'?: (event: CustomEvent) => void;
      'resettable'?: boolean;
      'submitError'?: string;
      'submitLabel'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaIframe {
      'fullscreen': boolean;
      'fullscreenMargin': string;
      'height': string;
      'src': string;
      'width': string;
      'zIndex': number;
    }
  }

  interface HTMLEmaIframeElement extends StencilComponents.EmaIframe, HTMLStencilElement {}

  var HTMLEmaIframeElement: {
    prototype: HTMLEmaIframeElement;
    new (): HTMLEmaIframeElement;
  };
  interface HTMLElementTagNameMap {
    'ema-iframe': HTMLEmaIframeElement;
  }
  interface ElementTagNameMap {
    'ema-iframe': HTMLEmaIframeElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-iframe': JSXElements.EmaIframeAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaIframeAttributes extends HTMLAttributes {
      'fullscreen'?: boolean;
      'fullscreenMargin'?: string;
      'height'?: string;
      'onIframeLoaded'?: (event: CustomEvent) => void;
      'src'?: string;
      'width'?: string;
      'zIndex'?: number;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaJsonViewer {
      'allowCopy': boolean;
      'collapseAt': number;
      'dataJson': string;
      'jsonUrl': string;
      'maxLevel': number;
    }
  }

  interface HTMLEmaJsonViewerElement extends StencilComponents.EmaJsonViewer, HTMLStencilElement {}

  var HTMLEmaJsonViewerElement: {
    prototype: HTMLEmaJsonViewerElement;
    new (): HTMLEmaJsonViewerElement;
  };
  interface HTMLElementTagNameMap {
    'ema-json-viewer': HTMLEmaJsonViewerElement;
  }
  interface ElementTagNameMap {
    'ema-json-viewer': HTMLEmaJsonViewerElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-json-viewer': JSXElements.EmaJsonViewerAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaJsonViewerAttributes extends HTMLAttributes {
      'allowCopy'?: boolean;
      'collapseAt'?: number;
      'dataJson'?: string;
      'jsonUrl'?: string;
      'maxLevel'?: number;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaLayout {
      'cellHeight': string;
      'cellWidth': string;
      'gridGap': string;
      'paddingStyle': string;
      'type': string;
    }
  }

  interface HTMLEmaLayoutElement extends StencilComponents.EmaLayout, HTMLStencilElement {}

  var HTMLEmaLayoutElement: {
    prototype: HTMLEmaLayoutElement;
    new (): HTMLEmaLayoutElement;
  };
  interface HTMLElementTagNameMap {
    'ema-layout': HTMLEmaLayoutElement;
  }
  interface ElementTagNameMap {
    'ema-layout': HTMLEmaLayoutElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-layout': JSXElements.EmaLayoutAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaLayoutAttributes extends HTMLAttributes {
      'cellHeight'?: string;
      'cellWidth'?: string;
      'gridGap'?: string;
      'paddingStyle'?: string;
      'type'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaLazyImg {
      'alt': string;
      'src': string;
    }
  }

  interface HTMLEmaLazyImgElement extends StencilComponents.EmaLazyImg, HTMLStencilElement {}

  var HTMLEmaLazyImgElement: {
    prototype: HTMLEmaLazyImgElement;
    new (): HTMLEmaLazyImgElement;
  };
  interface HTMLElementTagNameMap {
    'ema-lazy-img': HTMLEmaLazyImgElement;
  }
  interface ElementTagNameMap {
    'ema-lazy-img': HTMLEmaLazyImgElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-lazy-img': JSXElements.EmaLazyImgAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaLazyImgAttributes extends HTMLAttributes {
      'alt'?: string;
      'src'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaLoadingSpinner {
      'color': string;
      'hide': () => void;
      'show': () => void;
      'toggle': () => void;
      'type': string;
    }
  }

  interface HTMLEmaLoadingSpinnerElement extends StencilComponents.EmaLoadingSpinner, HTMLStencilElement {}

  var HTMLEmaLoadingSpinnerElement: {
    prototype: HTMLEmaLoadingSpinnerElement;
    new (): HTMLEmaLoadingSpinnerElement;
  };
  interface HTMLElementTagNameMap {
    'ema-loading-spinner': HTMLEmaLoadingSpinnerElement;
  }
  interface ElementTagNameMap {
    'ema-loading-spinner': HTMLEmaLoadingSpinnerElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-loading-spinner': JSXElements.EmaLoadingSpinnerAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaLoadingSpinnerAttributes extends HTMLAttributes {
      'color'?: string;
      'type'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaLoginForm {
      'errorMessage': string;
      'forgotPasswordLabel': string;
      'forgotPasswordUrl': string;
      'passwordLabel': string;
      'submitLabel': string;
      'usernameLabel': string;
    }
  }

  interface HTMLEmaLoginFormElement extends StencilComponents.EmaLoginForm, HTMLStencilElement {}

  var HTMLEmaLoginFormElement: {
    prototype: HTMLEmaLoginFormElement;
    new (): HTMLEmaLoginFormElement;
  };
  interface HTMLElementTagNameMap {
    'ema-login-form': HTMLEmaLoginFormElement;
  }
  interface ElementTagNameMap {
    'ema-login-form': HTMLEmaLoginFormElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-login-form': JSXElements.EmaLoginFormAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaLoginFormAttributes extends HTMLAttributes {
      'errorMessage'?: string;
      'forgotPasswordLabel'?: string;
      'forgotPasswordUrl'?: string;
      'onLoginShouldOccur'?: (event: CustomEvent) => void;
      'passwordLabel'?: string;
      'submitLabel'?: string;
      'usernameLabel'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaModal {
      'allowClose': string;
      'center': boolean;
      'centerHorizontal': boolean;
      'centerVertical': boolean;
      'height': string;
      'hide': () => void;
      'modalContent': string;
      'modalTitle': string;
      'show': (html: string) => void;
      'width': string;
    }
  }

  interface HTMLEmaModalElement extends StencilComponents.EmaModal, HTMLStencilElement {}

  var HTMLEmaModalElement: {
    prototype: HTMLEmaModalElement;
    new (): HTMLEmaModalElement;
  };
  interface HTMLElementTagNameMap {
    'ema-modal': HTMLEmaModalElement;
  }
  interface ElementTagNameMap {
    'ema-modal': HTMLEmaModalElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-modal': JSXElements.EmaModalAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaModalAttributes extends HTMLAttributes {
      'allowClose'?: string;
      'center'?: boolean;
      'centerHorizontal'?: boolean;
      'centerVertical'?: boolean;
      'height'?: string;
      'modalContent'?: string;
      'modalTitle'?: string;
      'width'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaPermission {
      'can': string;
      'cannot': string;
      'conditions': string;
      'getRules': () => any[];
      'isolate': boolean;
      'rulesJson': string;
      'setPermissionService': (instance: any) => void;
      'setRules': (rules: any[], replace?: boolean) => void;
      'subject': string;
      'update': () => void;
    }
  }

  interface HTMLEmaPermissionElement extends StencilComponents.EmaPermission, HTMLStencilElement {}

  var HTMLEmaPermissionElement: {
    prototype: HTMLEmaPermissionElement;
    new (): HTMLEmaPermissionElement;
  };
  interface HTMLElementTagNameMap {
    'ema-permission': HTMLEmaPermissionElement;
  }
  interface ElementTagNameMap {
    'ema-permission': HTMLEmaPermissionElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-permission': JSXElements.EmaPermissionAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaPermissionAttributes extends HTMLAttributes {
      'can'?: string;
      'cannot'?: string;
      'conditions'?: string;
      'isolate'?: boolean;
      'rulesJson'?: string;
      'subject'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaRepeater {
      'dataJson': string;
      'element': string;
      'setData': (content: any) => void;
      'setTemplate': (template: any) => void;
      'template': string;
    }
  }

  interface HTMLEmaRepeaterElement extends StencilComponents.EmaRepeater, HTMLStencilElement {}

  var HTMLEmaRepeaterElement: {
    prototype: HTMLEmaRepeaterElement;
    new (): HTMLEmaRepeaterElement;
  };
  interface HTMLElementTagNameMap {
    'ema-repeater': HTMLEmaRepeaterElement;
  }
  interface ElementTagNameMap {
    'ema-repeater': HTMLEmaRepeaterElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-repeater': JSXElements.EmaRepeaterAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaRepeaterAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'element'?: string;
      'template'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaSlider {
      'max': number;
      'min': number;
      'value': number;
    }
  }

  interface HTMLEmaSliderElement extends StencilComponents.EmaSlider, HTMLStencilElement {}

  var HTMLEmaSliderElement: {
    prototype: HTMLEmaSliderElement;
    new (): HTMLEmaSliderElement;
  };
  interface HTMLElementTagNameMap {
    'ema-slider': HTMLEmaSliderElement;
  }
  interface ElementTagNameMap {
    'ema-slider': HTMLEmaSliderElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-slider': JSXElements.EmaSliderAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaSliderAttributes extends HTMLAttributes {
      'max'?: number;
      'min'?: number;
      'onValueChanged'?: (event: CustomEvent) => void;
      'value'?: number;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaSvg {
      'dataJson': any;
      'getElements': () => any[];
      'src': string;
      'type': string;
    }
  }

  interface HTMLEmaSvgElement extends StencilComponents.EmaSvg, HTMLStencilElement {}

  var HTMLEmaSvgElement: {
    prototype: HTMLEmaSvgElement;
    new (): HTMLEmaSvgElement;
  };
  interface HTMLElementTagNameMap {
    'ema-svg': HTMLEmaSvgElement;
  }
  interface ElementTagNameMap {
    'ema-svg': HTMLEmaSvgElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-svg': JSXElements.EmaSvgAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaSvgAttributes extends HTMLAttributes {
      'dataJson'?: any;
      'onSvgElementClick'?: (event: CustomEvent) => void;
      'src'?: string;
      'type'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaTabContent {
      'getChild': () => IEmaTabContentData;
      'name': string;
    }
  }

  interface HTMLEmaTabContentElement extends StencilComponents.EmaTabContent, HTMLStencilElement {}

  var HTMLEmaTabContentElement: {
    prototype: HTMLEmaTabContentElement;
    new (): HTMLEmaTabContentElement;
  };
  interface HTMLElementTagNameMap {
    'ema-tab-content': HTMLEmaTabContentElement;
  }
  interface ElementTagNameMap {
    'ema-tab-content': HTMLEmaTabContentElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-tab-content': JSXElements.EmaTabContentAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaTabContentAttributes extends HTMLAttributes {
      'name'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaTabHeader {
      'getChild': () => IEmaTabHeaderData;
      'name': string;
    }
  }

  interface HTMLEmaTabHeaderElement extends StencilComponents.EmaTabHeader, HTMLStencilElement {}

  var HTMLEmaTabHeaderElement: {
    prototype: HTMLEmaTabHeaderElement;
    new (): HTMLEmaTabHeaderElement;
  };
  interface HTMLElementTagNameMap {
    'ema-tab-header': HTMLEmaTabHeaderElement;
  }
  interface ElementTagNameMap {
    'ema-tab-header': HTMLEmaTabHeaderElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-tab-header': JSXElements.EmaTabHeaderAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaTabHeaderAttributes extends HTMLAttributes {
      'name'?: string;
      'onOnSelect'?: (event: CustomEvent) => void;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaTabs {
      'selectedIndex': number;
    }
  }

  interface HTMLEmaTabsElement extends StencilComponents.EmaTabs, HTMLStencilElement {}

  var HTMLEmaTabsElement: {
    prototype: HTMLEmaTabsElement;
    new (): HTMLEmaTabsElement;
  };
  interface HTMLElementTagNameMap {
    'ema-tabs': HTMLEmaTabsElement;
  }
  interface ElementTagNameMap {
    'ema-tabs': HTMLEmaTabsElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-tabs': JSXElements.EmaTabsAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaTabsAttributes extends HTMLAttributes {
      'selectedIndex'?: number;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaTranslate {
      'get': (string: string) => string;
      'language': string;
      'params': string;
      'paramsJson': string;
      'set': (string: string, language: string, transform: any) => void;
      'setTranslateService': (instance: any) => void;
      'string': string;
      'transform': string;
      'translationsLocation': string;
      'update': () => void;
    }
  }

  interface HTMLEmaTranslateElement extends StencilComponents.EmaTranslate, HTMLStencilElement {}

  var HTMLEmaTranslateElement: {
    prototype: HTMLEmaTranslateElement;
    new (): HTMLEmaTranslateElement;
  };
  interface HTMLElementTagNameMap {
    'ema-translate': HTMLEmaTranslateElement;
  }
  interface ElementTagNameMap {
    'ema-translate': HTMLEmaTranslateElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-translate': JSXElements.EmaTranslateAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaTranslateAttributes extends HTMLAttributes {
      'language'?: string;
      'params'?: string;
      'paramsJson'?: string;
      'string'?: string;
      'transform'?: string;
      'translationsLocation'?: string;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaTypeAhead {
      'dataJson': string;
      'options': any;
    }
  }

  interface HTMLEmaTypeAheadElement extends StencilComponents.EmaTypeAhead, HTMLStencilElement {}

  var HTMLEmaTypeAheadElement: {
    prototype: HTMLEmaTypeAheadElement;
    new (): HTMLEmaTypeAheadElement;
  };
  interface HTMLElementTagNameMap {
    'ema-type-ahead': HTMLEmaTypeAheadElement;
  }
  interface ElementTagNameMap {
    'ema-type-ahead': HTMLEmaTypeAheadElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-type-ahead': JSXElements.EmaTypeAheadAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaTypeAheadAttributes extends HTMLAttributes {
      'dataJson'?: string;
      'onSearch'?: (event: CustomEvent) => void;
      'onSelection'?: (event: CustomEvent) => void;
      'options'?: any;
    }
  }
}


declare global {

  namespace StencilComponents {
    interface EmaPost {
      'dataJson': string;
    }
  }

  interface HTMLEmaPostElement extends StencilComponents.EmaPost, HTMLStencilElement {}

  var HTMLEmaPostElement: {
    prototype: HTMLEmaPostElement;
    new (): HTMLEmaPostElement;
  };
  interface HTMLElementTagNameMap {
    'ema-post': HTMLEmaPostElement;
  }
  interface ElementTagNameMap {
    'ema-post': HTMLEmaPostElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-post': JSXElements.EmaPostAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaPostAttributes extends HTMLAttributes {
      'dataJson'?: string;
    }
  }
}

declare global { namespace JSX { interface StencilJSX {} } }

export declare function defineCustomElements(window: any): void;