/* eslint-disable */
/* tslint:disable */
/**
 * This is an autogenerated file created by the Stencil compiler.
 * It contains typing information for all components that exist in this project.
 */


import { HTMLStencilElement, JSXBase } from './stencil.core';
import {
  IArtistFilters,
  IArtistOption,
} from './types/artists';
import {
  IWebCompleteResponse,
} from './types/web-complete';
import {
  FormInput,
} from './objects/form-input';
import {
  IDmaOption,
  IDmasFilter,
} from './types/dmas';
import {
  IEventOption,
  IEventsFilter,
} from './types/events';
import {
  IMarketToggleOption,
  IPostalCodeFilter,
  IPostalCodeOption,
} from './types/locations';
import {
  ISelectableOption,
  IToggleableOption,
} from './types/option-lists';

export namespace Components {
  interface LemiArtistOption {
    'allowToggle': boolean;
    'artist': IArtistOption;
    'enabled': boolean;
    'refreshArtist': (newArtistData: any) => Promise<void>;
  }
  interface LemiArtists {
    'artistsData': any;
    'frequencyCapIncludeIfAttractedToPrimaryArtist': any;
    'getFilters': () => Promise<IArtistFilters>;
    'inputValue': any;
    'selectedArtists': any;
    'setAllSelected': () => Promise<void>;
    'setSelectionByValue': (newValue: any) => Promise<void>;
  }
  interface LemiAudienceBuilder {
    'allowed_markets': string;
    'api_url': any;
    'artists_data': any;
    'cpm': string;
    'display_allowed_markets': any;
    'dmas_data': any;
    'enable_slider': string;
    'events_data': any;
    'id': string;
    'is_user_admin': any;
    'last_import_date': string;
    'name': string;
    'newsletter_id': any;
    'selected_artist_ids': any;
    'selected_dma_ids': any;
    'selected_event_ids': any;
    'show_exclude_primary_event_purchasers': string;
    'show_include_attracted_to_primary_artist': string;
    'show_include_primary_event_purchasers': string;
    'show_markets_selector': string;
    'show_tick_marks': any;
    'value': any;
  }
  interface LemiAutoComplete {
    'allowSelectMultiple': boolean;
    'bufferTime': number;
    'getText': () => Promise<string>;
    'getValue': () => Promise<string>;
    'maxSuggestions': number;
    'minInput': number;
    'onSelected': (event: CustomEvent) => any;
    'placeholder': string;
    'queryParam': string;
    'queryPath': string;
    'responseProcessor': (response) => IWebCompleteResponse[];
    'suggestionGenerator': (search: string) => Promise<IWebCompleteResponse[]>;
  }
  interface LemiCard {
    'allowToggle': boolean;
    'cardId': string;
    'cardTitle': string;
    'colSize': string;
    'getEnabled': () => Promise<boolean>;
    'imageUrl': string;
    'inputData': FormInput;
  }
  interface LemiDmaOption {
    'allowToggle': boolean;
    'dma': IDmaOption;
    'isDisabled': boolean;
  }
  interface LemiDmas {
    'dmasData': any;
    'enabled': boolean;
    'frequencyCapExcludeIfAlreadyPurchasedTicketToPrimaryDma': any;
    'getFilters': () => Promise<IDmasFilter>;
    'inputData': FormInput;
    'marketId': string;
    'selectedDmas': any;
  }
  interface LemiEventOption {
    'allowToggle': boolean;
    'event': IEventOption;
    'refreshEvent': (newEventData: any) => Promise<void>;
  }
  interface LemiEvents {
    'eventsData': any;
    'frequencyCapExcludeIfAlreadyPurchasedTicketToPrimaryEvent': any;
    'frequencyCapIncludeIfAlreadyPurchasedTicketToPrimaryEvent': any;
    'getFilters': () => Promise<IEventsFilter>;
    'inputData': FormInput;
    'selectedEvents': any;
    'setSelectionByValue': (newValue: any) => Promise<void>;
  }
  interface LemiMarketOption {
    'allowToggle': boolean;
    'market': IMarketToggleOption;
  }
  interface LemiMarkets {
    'allowedMarkets': any[];
    'displayAllowedMarkets': boolean;
    'getFilters': () => Promise<any>;
    'inputData': any[];
    'showMarketsSelector': boolean;
  }
  interface LemiOptionList {
    'options': IToggleableOption[];
  }
  interface LemiPostalCodeOption {
    'index': number;
    'postalCode': IPostalCodeOption;
    'refreshPostalCode': (newValue: any) => Promise<void>;
  }
  interface LemiPostalCodes {
    'getFilters': () => Promise<IPostalCodeFilter>;
    'postalCodesValue': IPostalCodeOption[];
    'refreshPostalCodes': () => Promise<void>;
    'reloadPostalCodes': (newValue: any) => Promise<void>;
  }
  interface LemiPreloader {
    'containerClass': string;
    'loading': boolean;
    'width'?: string|number;
  }
  interface LemiSelect {
    'enabled': boolean;
    'optionSelected': string;
    'options': ISelectableOption[];
    'placeholder': string;
  }
  interface LemiToggleOption {
    'allowCollapse': boolean;
    'allowRemove': boolean;
    'allowToggle': boolean;
    'hasOptions': boolean;
    'isChecked': boolean;
    'isCollapsed': boolean;
    'isDisabled': boolean;
    'option': IToggleableOption;
    'optionId': string;
    'setOptionValue': (optionValue: any) => Promise<void>;
  }
  interface LemiToggleSwitch {
    'enabled': boolean;
    'options': ISelectableOption[];
  }
  interface WebComplete {
    /**
    * Number of ms to wait before fetching suggestions after keypress
    */
    'bufferTime': number|null;
    /**
    * Allows to close list after option is selected
    */
    'closeAfterSelect': boolean;
    /**
    * The class names, which should be set on the rendered html elements
    */
    'cssClasses': { wrapper: string; input: string; suggestions: string; suggestion: string; active: string; };
    /**
    * Enable/Disable the input field
    */
    'disabled': boolean;
    /**
    * Returns the `text` of the selected item
    */
    'getText': () => Promise<string>;
    /**
    * Returns the `value` of the selected item
    */
    'getValue': () => Promise<string>;
    /**
    * The maximally shown suggestions in the list
    */
    'maxSuggestions': number;
    /**
    * The minimum input size for generating suggestions
    */
    'minInput': number;
    /**
    * The placeholder for the input field
    */
    'placeholder': string;
    /**
    * Removes value from list after select
    */
    'removeValueFromResultsAfterSelect': boolean;
    /**
    * Async suggestion generator: `text` is the displayed for users `value` is the actual value of the form field
    */
    'suggestionGenerator': (text: string) => Promise<Array<{ text: string, value: string }>>;
    /**
    * The text is displayed by the form field for users
    */
    'text': string;
    /**
    * The actual value of the form field
    */
    'value': string;
  }
  interface WebixSlider {
    'cssClass': string;
    'disableSlider': () => Promise<void>;
    'disabled': boolean;
    'enableSlider': () => Promise<void>;
    'max': number;
    'min': number;
    'showTickMarks': boolean;
    'step': number;
    'value': string;
    'visible': boolean;
  }
}

declare global {


  interface HTMLLemiArtistOptionElement extends Components.LemiArtistOption, HTMLStencilElement {}
  var HTMLLemiArtistOptionElement: {
    prototype: HTMLLemiArtistOptionElement;
    new (): HTMLLemiArtistOptionElement;
  };

  interface HTMLLemiArtistsElement extends Components.LemiArtists, HTMLStencilElement {}
  var HTMLLemiArtistsElement: {
    prototype: HTMLLemiArtistsElement;
    new (): HTMLLemiArtistsElement;
  };

  interface HTMLLemiAudienceBuilderElement extends Components.LemiAudienceBuilder, HTMLStencilElement {}
  var HTMLLemiAudienceBuilderElement: {
    prototype: HTMLLemiAudienceBuilderElement;
    new (): HTMLLemiAudienceBuilderElement;
  };

  interface HTMLLemiAutoCompleteElement extends Components.LemiAutoComplete, HTMLStencilElement {}
  var HTMLLemiAutoCompleteElement: {
    prototype: HTMLLemiAutoCompleteElement;
    new (): HTMLLemiAutoCompleteElement;
  };

  interface HTMLLemiCardElement extends Components.LemiCard, HTMLStencilElement {}
  var HTMLLemiCardElement: {
    prototype: HTMLLemiCardElement;
    new (): HTMLLemiCardElement;
  };

  interface HTMLLemiDmaOptionElement extends Components.LemiDmaOption, HTMLStencilElement {}
  var HTMLLemiDmaOptionElement: {
    prototype: HTMLLemiDmaOptionElement;
    new (): HTMLLemiDmaOptionElement;
  };

  interface HTMLLemiDmasElement extends Components.LemiDmas, HTMLStencilElement {}
  var HTMLLemiDmasElement: {
    prototype: HTMLLemiDmasElement;
    new (): HTMLLemiDmasElement;
  };

  interface HTMLLemiEventOptionElement extends Components.LemiEventOption, HTMLStencilElement {}
  var HTMLLemiEventOptionElement: {
    prototype: HTMLLemiEventOptionElement;
    new (): HTMLLemiEventOptionElement;
  };

  interface HTMLLemiEventsElement extends Components.LemiEvents, HTMLStencilElement {}
  var HTMLLemiEventsElement: {
    prototype: HTMLLemiEventsElement;
    new (): HTMLLemiEventsElement;
  };

  interface HTMLLemiMarketOptionElement extends Components.LemiMarketOption, HTMLStencilElement {}
  var HTMLLemiMarketOptionElement: {
    prototype: HTMLLemiMarketOptionElement;
    new (): HTMLLemiMarketOptionElement;
  };

  interface HTMLLemiMarketsElement extends Components.LemiMarkets, HTMLStencilElement {}
  var HTMLLemiMarketsElement: {
    prototype: HTMLLemiMarketsElement;
    new (): HTMLLemiMarketsElement;
  };

  interface HTMLLemiOptionListElement extends Components.LemiOptionList, HTMLStencilElement {}
  var HTMLLemiOptionListElement: {
    prototype: HTMLLemiOptionListElement;
    new (): HTMLLemiOptionListElement;
  };

  interface HTMLLemiPostalCodeOptionElement extends Components.LemiPostalCodeOption, HTMLStencilElement {}
  var HTMLLemiPostalCodeOptionElement: {
    prototype: HTMLLemiPostalCodeOptionElement;
    new (): HTMLLemiPostalCodeOptionElement;
  };

  interface HTMLLemiPostalCodesElement extends Components.LemiPostalCodes, HTMLStencilElement {}
  var HTMLLemiPostalCodesElement: {
    prototype: HTMLLemiPostalCodesElement;
    new (): HTMLLemiPostalCodesElement;
  };

  interface HTMLLemiPreloaderElement extends Components.LemiPreloader, HTMLStencilElement {}
  var HTMLLemiPreloaderElement: {
    prototype: HTMLLemiPreloaderElement;
    new (): HTMLLemiPreloaderElement;
  };

  interface HTMLLemiSelectElement extends Components.LemiSelect, HTMLStencilElement {}
  var HTMLLemiSelectElement: {
    prototype: HTMLLemiSelectElement;
    new (): HTMLLemiSelectElement;
  };

  interface HTMLLemiToggleOptionElement extends Components.LemiToggleOption, HTMLStencilElement {}
  var HTMLLemiToggleOptionElement: {
    prototype: HTMLLemiToggleOptionElement;
    new (): HTMLLemiToggleOptionElement;
  };

  interface HTMLLemiToggleSwitchElement extends Components.LemiToggleSwitch, HTMLStencilElement {}
  var HTMLLemiToggleSwitchElement: {
    prototype: HTMLLemiToggleSwitchElement;
    new (): HTMLLemiToggleSwitchElement;
  };

  interface HTMLWebCompleteElement extends Components.WebComplete, HTMLStencilElement {}
  var HTMLWebCompleteElement: {
    prototype: HTMLWebCompleteElement;
    new (): HTMLWebCompleteElement;
  };

  interface HTMLWebixSliderElement extends Components.WebixSlider, HTMLStencilElement {}
  var HTMLWebixSliderElement: {
    prototype: HTMLWebixSliderElement;
    new (): HTMLWebixSliderElement;
  };
  interface HTMLElementTagNameMap {
    'lemi-artist-option': HTMLLemiArtistOptionElement;
    'lemi-artists': HTMLLemiArtistsElement;
    'lemi-audience-builder': HTMLLemiAudienceBuilderElement;
    'lemi-auto-complete': HTMLLemiAutoCompleteElement;
    'lemi-card': HTMLLemiCardElement;
    'lemi-dma-option': HTMLLemiDmaOptionElement;
    'lemi-dmas': HTMLLemiDmasElement;
    'lemi-event-option': HTMLLemiEventOptionElement;
    'lemi-events': HTMLLemiEventsElement;
    'lemi-market-option': HTMLLemiMarketOptionElement;
    'lemi-markets': HTMLLemiMarketsElement;
    'lemi-option-list': HTMLLemiOptionListElement;
    'lemi-postal-code-option': HTMLLemiPostalCodeOptionElement;
    'lemi-postal-codes': HTMLLemiPostalCodesElement;
    'lemi-preloader': HTMLLemiPreloaderElement;
    'lemi-select': HTMLLemiSelectElement;
    'lemi-toggle-option': HTMLLemiToggleOptionElement;
    'lemi-toggle-switch': HTMLLemiToggleSwitchElement;
    'web-complete': HTMLWebCompleteElement;
    'webix-slider': HTMLWebixSliderElement;
  }
}

declare namespace LocalJSX {
  interface LemiArtistOption {
    'allowToggle'?: boolean;
    'artist'?: IArtistOption;
    'enabled'?: boolean;
    'onOptionRemoved'?: (event: CustomEvent<any>) => void;
    'onValueChanged'?: (event: CustomEvent<any>) => void;
  }
  interface LemiArtists {
    'artistsData'?: any;
    'frequencyCapIncludeIfAttractedToPrimaryArtist'?: any;
    'inputValue'?: any;
    'onArtistFiltersChanged'?: (event: CustomEvent<any>) => void;
    'onDisableSlider'?: (event: CustomEvent<any>) => void;
    'selectedArtists'?: any;
  }
  interface LemiAudienceBuilder {
    'allowed_markets'?: string;
    'api_url'?: any;
    'artists_data'?: any;
    'cpm'?: string;
    'display_allowed_markets'?: any;
    'dmas_data'?: any;
    'enable_slider'?: string;
    'events_data'?: any;
    'id'?: string;
    'is_user_admin'?: any;
    'last_import_date'?: string;
    'name'?: string;
    'newsletter_id'?: any;
    'onAudienceChanged'?: (event: CustomEvent<any>) => void;
    'selected_artist_ids'?: any;
    'selected_dma_ids'?: any;
    'selected_event_ids'?: any;
    'show_exclude_primary_event_purchasers'?: string;
    'show_include_attracted_to_primary_artist'?: string;
    'show_include_primary_event_purchasers'?: string;
    'show_markets_selector'?: string;
    'show_tick_marks'?: any;
    'value'?: any;
  }
  interface LemiAutoComplete {
    'allowSelectMultiple'?: boolean;
    'bufferTime'?: number;
    'maxSuggestions'?: number;
    'minInput'?: number;
    'onSelected'?: (event: CustomEvent) => any;
    'placeholder'?: string;
    'queryParam'?: string;
    'queryPath'?: string;
    'responseProcessor'?: (response) => IWebCompleteResponse[];
    'suggestionGenerator'?: (search: string) => Promise<IWebCompleteResponse[]>;
  }
  interface LemiCard {
    'allowToggle'?: boolean;
    'cardId'?: string;
    'cardTitle'?: string;
    'colSize'?: string;
    'imageUrl'?: string;
    'inputData'?: FormInput;
    'onDisableSlider'?: (event: CustomEvent<any>) => void;
    'onStateChanged'?: (event: CustomEvent<any>) => void;
  }
  interface LemiDmaOption {
    'allowToggle'?: boolean;
    'dma'?: IDmaOption;
    'isDisabled'?: boolean;
    'onValueChanged'?: (event: CustomEvent<any>) => void;
  }
  interface LemiDmas {
    'dmasData'?: any;
    'enabled'?: boolean;
    'frequencyCapExcludeIfAlreadyPurchasedTicketToPrimaryDma'?: any;
    'inputData'?: FormInput;
    'marketId'?: string;
    'onDmaFiltersChanged'?: (event: CustomEvent<any>) => void;
    'selectedDmas'?: any;
  }
  interface LemiEventOption {
    'allowToggle'?: boolean;
    'event'?: IEventOption;
    'onValueChanged'?: (event: CustomEvent<any>) => void;
  }
  interface LemiEvents {
    'eventsData'?: any;
    'frequencyCapExcludeIfAlreadyPurchasedTicketToPrimaryEvent'?: any;
    'frequencyCapIncludeIfAlreadyPurchasedTicketToPrimaryEvent'?: any;
    'inputData'?: FormInput;
    'onDisableSlider'?: (event: CustomEvent<any>) => void;
    'onEventFiltersChanged'?: (event: CustomEvent<any>) => void;
    'selectedEvents'?: any;
  }
  interface LemiMarketOption {
    'allowToggle'?: boolean;
    'market'?: IMarketToggleOption;
    'onOptionRemoved'?: (event: CustomEvent<any>) => void;
    'onValueChanged'?: (event: CustomEvent<any>) => void;
  }
  interface LemiMarkets {
    'allowedMarkets'?: any[];
    'displayAllowedMarkets'?: boolean;
    'inputData'?: any[];
    'onStateChanged'?: (event: CustomEvent<any>) => void;
    'showMarketsSelector'?: boolean;
  }
  interface LemiOptionList {
    'onStateChanged'?: (event: CustomEvent<any>) => void;
    'options'?: IToggleableOption[];
  }
  interface LemiPostalCodeOption {
    'index'?: number;
    'onPostalCodeChanged'?: (event: CustomEvent<any>) => void;
    'postalCode'?: IPostalCodeOption;
  }
  interface LemiPostalCodes {
    'onDisableSlider'?: (event: CustomEvent<any>) => void;
    'onPostalCodesSelectChanged'?: (event: CustomEvent<any>) => void;
    'postalCodesValue'?: IPostalCodeOption[];
  }
  interface LemiPreloader {
    'containerClass'?: string;
    'loading'?: boolean;
    'width'?: string|number;
  }
  interface LemiSelect {
    'enabled'?: boolean;
    'onDisableSlider'?: (event: CustomEvent<any>) => void;
    'onSelectChanged'?: (event: CustomEvent<any>) => void;
    'onStateChanged'?: (event: CustomEvent<any>) => void;
    'optionSelected'?: string;
    'options'?: ISelectableOption[];
    'placeholder'?: string;
  }
  interface LemiToggleOption {
    'allowCollapse'?: boolean;
    'allowRemove'?: boolean;
    'allowToggle'?: boolean;
    'hasOptions'?: boolean;
    'isChecked'?: boolean;
    'isCollapsed'?: boolean;
    'isDisabled'?: boolean;
    'onCollapseClicked'?: (event: CustomEvent<any>) => void;
    'onDisableSlider'?: (event: CustomEvent<any>) => void;
    'onOptionRemoved'?: (event: CustomEvent<any>) => void;
    'onStateChanged'?: (event: CustomEvent<any>) => void;
    'option'?: IToggleableOption;
    'optionId'?: string;
  }
  interface LemiToggleSwitch {
    'enabled'?: boolean;
    'onDisableSlider'?: (event: CustomEvent<any>) => void;
    'onSelectChanged'?: (event: CustomEvent<any>) => void;
    'onStateChanged'?: (event: CustomEvent<any>) => void;
    'options'?: ISelectableOption[];
  }
  interface WebComplete {
    /**
    * Number of ms to wait before fetching suggestions after keypress
    */
    'bufferTime'?: number|null;
    /**
    * Allows to close list after option is selected
    */
    'closeAfterSelect'?: boolean;
    /**
    * The class names, which should be set on the rendered html elements
    */
    'cssClasses'?: { wrapper: string; input: string; suggestions: string; suggestion: string; active: string; };
    /**
    * Enable/Disable the input field
    */
    'disabled'?: boolean;
    /**
    * The maximally shown suggestions in the list
    */
    'maxSuggestions'?: number;
    /**
    * The minimum input size for generating suggestions
    */
    'minInput'?: number;
    /**
    * Emitted when an item from suggestions was selected
    */
    'onSelected'?: (event: CustomEvent<any>) => void;
    /**
    * Emitted when item was cleared/unselected
    */
    'onUnselected'?: (event: CustomEvent<any>) => void;
    /**
    * The placeholder for the input field
    */
    'placeholder'?: string;
    /**
    * Removes value from list after select
    */
    'removeValueFromResultsAfterSelect'?: boolean;
    /**
    * Async suggestion generator: `text` is the displayed for users `value` is the actual value of the form field
    */
    'suggestionGenerator'?: (text: string) => Promise<Array<{ text: string, value: string }>>;
    /**
    * The text is displayed by the form field for users
    */
    'text'?: string;
    /**
    * The actual value of the form field
    */
    'value'?: string;
  }
  interface WebixSlider {
    'cssClass'?: string;
    'disabled'?: boolean;
    'max'?: number;
    'min'?: number;
    'onSliderChange'?: (event: CustomEvent<any>) => void;
    'onSliderMouseDown'?: (event: CustomEvent<any>) => void;
    'showTickMarks'?: boolean;
    'step'?: number;
    'value'?: string;
    'visible'?: boolean;
  }

  interface IntrinsicElements {
    'lemi-artist-option': LemiArtistOption;
    'lemi-artists': LemiArtists;
    'lemi-audience-builder': LemiAudienceBuilder;
    'lemi-auto-complete': LemiAutoComplete;
    'lemi-card': LemiCard;
    'lemi-dma-option': LemiDmaOption;
    'lemi-dmas': LemiDmas;
    'lemi-event-option': LemiEventOption;
    'lemi-events': LemiEvents;
    'lemi-market-option': LemiMarketOption;
    'lemi-markets': LemiMarkets;
    'lemi-option-list': LemiOptionList;
    'lemi-postal-code-option': LemiPostalCodeOption;
    'lemi-postal-codes': LemiPostalCodes;
    'lemi-preloader': LemiPreloader;
    'lemi-select': LemiSelect;
    'lemi-toggle-option': LemiToggleOption;
    'lemi-toggle-switch': LemiToggleSwitch;
    'web-complete': WebComplete;
    'webix-slider': WebixSlider;
  }
}

export { LocalJSX as JSX };


declare module "@stencil/core" {
  export namespace JSX {
    interface IntrinsicElements {
      'lemi-artist-option': LocalJSX.LemiArtistOption & JSXBase.HTMLAttributes<HTMLLemiArtistOptionElement>;
      'lemi-artists': LocalJSX.LemiArtists & JSXBase.HTMLAttributes<HTMLLemiArtistsElement>;
      'lemi-audience-builder': LocalJSX.LemiAudienceBuilder & JSXBase.HTMLAttributes<HTMLLemiAudienceBuilderElement>;
      'lemi-auto-complete': LocalJSX.LemiAutoComplete & JSXBase.HTMLAttributes<HTMLLemiAutoCompleteElement>;
      'lemi-card': LocalJSX.LemiCard & JSXBase.HTMLAttributes<HTMLLemiCardElement>;
      'lemi-dma-option': LocalJSX.LemiDmaOption & JSXBase.HTMLAttributes<HTMLLemiDmaOptionElement>;
      'lemi-dmas': LocalJSX.LemiDmas & JSXBase.HTMLAttributes<HTMLLemiDmasElement>;
      'lemi-event-option': LocalJSX.LemiEventOption & JSXBase.HTMLAttributes<HTMLLemiEventOptionElement>;
      'lemi-events': LocalJSX.LemiEvents & JSXBase.HTMLAttributes<HTMLLemiEventsElement>;
      'lemi-market-option': LocalJSX.LemiMarketOption & JSXBase.HTMLAttributes<HTMLLemiMarketOptionElement>;
      'lemi-markets': LocalJSX.LemiMarkets & JSXBase.HTMLAttributes<HTMLLemiMarketsElement>;
      'lemi-option-list': LocalJSX.LemiOptionList & JSXBase.HTMLAttributes<HTMLLemiOptionListElement>;
      'lemi-postal-code-option': LocalJSX.LemiPostalCodeOption & JSXBase.HTMLAttributes<HTMLLemiPostalCodeOptionElement>;
      'lemi-postal-codes': LocalJSX.LemiPostalCodes & JSXBase.HTMLAttributes<HTMLLemiPostalCodesElement>;
      'lemi-preloader': LocalJSX.LemiPreloader & JSXBase.HTMLAttributes<HTMLLemiPreloaderElement>;
      'lemi-select': LocalJSX.LemiSelect & JSXBase.HTMLAttributes<HTMLLemiSelectElement>;
      'lemi-toggle-option': LocalJSX.LemiToggleOption & JSXBase.HTMLAttributes<HTMLLemiToggleOptionElement>;
      'lemi-toggle-switch': LocalJSX.LemiToggleSwitch & JSXBase.HTMLAttributes<HTMLLemiToggleSwitchElement>;
      'web-complete': LocalJSX.WebComplete & JSXBase.HTMLAttributes<HTMLWebCompleteElement>;
      'webix-slider': LocalJSX.WebixSlider & JSXBase.HTMLAttributes<HTMLWebixSliderElement>;
    }
  }
}