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 {
  IStcTabContentData,
  IStcTabHeaderData,
} from './components/tabs/interfaces';

declare global {

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

  interface HTMLEmaAppArchitectureElement extends StencilComponents.EmaAppArchitecture, HTMLStencilElement {}

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


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 EmaAppDocumentation {
      'match': MatchResults;
    }
  }

  interface HTMLEmaAppDocumentationElement extends StencilComponents.EmaAppDocumentation, HTMLStencilElement {}

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


declare global {

  namespace StencilComponents {
    interface EmaAppDrupal {
      '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 {
      'match'?: MatchResults;
    }
  }
}


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 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 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 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;
    }
  }

  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 EmaNode {
      'dataJson': string;
    }
  }

  interface HTMLEmaNodeElement extends StencilComponents.EmaNode, HTMLStencilElement {}

  var HTMLEmaNodeElement: {
    prototype: HTMLEmaNodeElement;
    new (): HTMLEmaNodeElement;
  };
  interface HTMLElementTagNameMap {
    'ema-node': HTMLEmaNodeElement;
  }
  interface ElementTagNameMap {
    'ema-node': HTMLEmaNodeElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-node': JSXElements.EmaNodeAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaNodeAttributes 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 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;
      'padding': 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;
      'padding'?: 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 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': () => IStcTabContentData;
      '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': () => IStcTabHeaderData;
      '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 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 StencilComponents {
    interface EmaBaseComponent {

    }
  }

  interface HTMLEmaBaseComponentElement extends StencilComponents.EmaBaseComponent, HTMLStencilElement {}

  var HTMLEmaBaseComponentElement: {
    prototype: HTMLEmaBaseComponentElement;
    new (): HTMLEmaBaseComponentElement;
  };
  interface HTMLElementTagNameMap {
    'ema-base-component': HTMLEmaBaseComponentElement;
  }
  interface ElementTagNameMap {
    'ema-base-component': HTMLEmaBaseComponentElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      'ema-base-component': JSXElements.EmaBaseComponentAttributes;
    }
  }
  namespace JSXElements {
    export interface EmaBaseComponentAttributes extends HTMLAttributes {

    }
  }
}

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

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