/* eslint-disable */
/* tslint:disable */
/* auto-generated vue proxies */
import { defineContainer, type StencilVueComponent } from '@stencil/vue-output-target/runtime';

import type { JSX } from '@ionic/core';

import { defineCustomElement as defineIonAccordion } from '@ionic/core/components/ion-accordion.js';
import { defineCustomElement as defineIonAccordionGroup } from '@ionic/core/components/ion-accordion-group.js';
import { defineCustomElement as defineIonAvatar } from '@ionic/core/components/ion-avatar.js';
import { defineCustomElement as defineIonBackdrop } from '@ionic/core/components/ion-backdrop.js';
import { defineCustomElement as defineIonBadge } from '@ionic/core/components/ion-badge.js';
import { defineCustomElement as defineIonBreadcrumb } from '@ionic/core/components/ion-breadcrumb.js';
import { defineCustomElement as defineIonBreadcrumbs } from '@ionic/core/components/ion-breadcrumbs.js';
import { defineCustomElement as defineIonButton } from '@ionic/core/components/ion-button.js';
import { defineCustomElement as defineIonButtons } from '@ionic/core/components/ion-buttons.js';
import { defineCustomElement as defineIonCard } from '@ionic/core/components/ion-card.js';
import { defineCustomElement as defineIonCardContent } from '@ionic/core/components/ion-card-content.js';
import { defineCustomElement as defineIonCardHeader } from '@ionic/core/components/ion-card-header.js';
import { defineCustomElement as defineIonCardSubtitle } from '@ionic/core/components/ion-card-subtitle.js';
import { defineCustomElement as defineIonCardTitle } from '@ionic/core/components/ion-card-title.js';
import { defineCustomElement as defineIonCheckbox } from '@ionic/core/components/ion-checkbox.js';
import { defineCustomElement as defineIonChip } from '@ionic/core/components/ion-chip.js';
import { defineCustomElement as defineIonCol } from '@ionic/core/components/ion-col.js';
import { defineCustomElement as defineIonContent } from '@ionic/core/components/ion-content.js';
import { defineCustomElement as defineIonDatetime } from '@ionic/core/components/ion-datetime.js';
import { defineCustomElement as defineIonDatetimeButton } from '@ionic/core/components/ion-datetime-button.js';
import { defineCustomElement as defineIonFab } from '@ionic/core/components/ion-fab.js';
import { defineCustomElement as defineIonFabButton } from '@ionic/core/components/ion-fab-button.js';
import { defineCustomElement as defineIonFabList } from '@ionic/core/components/ion-fab-list.js';
import { defineCustomElement as defineIonFooter } from '@ionic/core/components/ion-footer.js';
import { defineCustomElement as defineIonGrid } from '@ionic/core/components/ion-grid.js';
import { defineCustomElement as defineIonHeader } from '@ionic/core/components/ion-header.js';
import { defineCustomElement as defineIonImg } from '@ionic/core/components/ion-img.js';
import { defineCustomElement as defineIonInfiniteScroll } from '@ionic/core/components/ion-infinite-scroll.js';
import { defineCustomElement as defineIonInfiniteScrollContent } from '@ionic/core/components/ion-infinite-scroll-content.js';
import { defineCustomElement as defineIonInput } from '@ionic/core/components/ion-input.js';
import { defineCustomElement as defineIonInputOtp } from '@ionic/core/components/ion-input-otp.js';
import { defineCustomElement as defineIonInputPasswordToggle } from '@ionic/core/components/ion-input-password-toggle.js';
import { defineCustomElement as defineIonItem } from '@ionic/core/components/ion-item.js';
import { defineCustomElement as defineIonItemDivider } from '@ionic/core/components/ion-item-divider.js';
import { defineCustomElement as defineIonItemGroup } from '@ionic/core/components/ion-item-group.js';
import { defineCustomElement as defineIonItemOption } from '@ionic/core/components/ion-item-option.js';
import { defineCustomElement as defineIonItemOptions } from '@ionic/core/components/ion-item-options.js';
import { defineCustomElement as defineIonItemSliding } from '@ionic/core/components/ion-item-sliding.js';
import { defineCustomElement as defineIonLabel } from '@ionic/core/components/ion-label.js';
import { defineCustomElement as defineIonList } from '@ionic/core/components/ion-list.js';
import { defineCustomElement as defineIonListHeader } from '@ionic/core/components/ion-list-header.js';
import { defineCustomElement as defineIonMenu } from '@ionic/core/components/ion-menu.js';
import { defineCustomElement as defineIonMenuButton } from '@ionic/core/components/ion-menu-button.js';
import { defineCustomElement as defineIonMenuToggle } from '@ionic/core/components/ion-menu-toggle.js';
import { defineCustomElement as defineIonNav } from '@ionic/core/components/ion-nav.js';
import { defineCustomElement as defineIonNavLink } from '@ionic/core/components/ion-nav-link.js';
import { defineCustomElement as defineIonNote } from '@ionic/core/components/ion-note.js';
import { defineCustomElement as defineIonPicker } from '@ionic/core/components/ion-picker.js';
import { defineCustomElement as defineIonPickerColumn } from '@ionic/core/components/ion-picker-column.js';
import { defineCustomElement as defineIonPickerColumnOption } from '@ionic/core/components/ion-picker-column-option.js';
import { defineCustomElement as defineIonProgressBar } from '@ionic/core/components/ion-progress-bar.js';
import { defineCustomElement as defineIonRadio } from '@ionic/core/components/ion-radio.js';
import { defineCustomElement as defineIonRadioGroup } from '@ionic/core/components/ion-radio-group.js';
import { defineCustomElement as defineIonRange } from '@ionic/core/components/ion-range.js';
import { defineCustomElement as defineIonRefresher } from '@ionic/core/components/ion-refresher.js';
import { defineCustomElement as defineIonRefresherContent } from '@ionic/core/components/ion-refresher-content.js';
import { defineCustomElement as defineIonReorder } from '@ionic/core/components/ion-reorder.js';
import { defineCustomElement as defineIonReorderGroup } from '@ionic/core/components/ion-reorder-group.js';
import { defineCustomElement as defineIonRippleEffect } from '@ionic/core/components/ion-ripple-effect.js';
import { defineCustomElement as defineIonRow } from '@ionic/core/components/ion-row.js';
import { defineCustomElement as defineIonSearchbar } from '@ionic/core/components/ion-searchbar.js';
import { defineCustomElement as defineIonSegment } from '@ionic/core/components/ion-segment.js';
import { defineCustomElement as defineIonSegmentButton } from '@ionic/core/components/ion-segment-button.js';
import { defineCustomElement as defineIonSegmentContent } from '@ionic/core/components/ion-segment-content.js';
import { defineCustomElement as defineIonSegmentView } from '@ionic/core/components/ion-segment-view.js';
import { defineCustomElement as defineIonSelect } from '@ionic/core/components/ion-select.js';
import { defineCustomElement as defineIonSelectModal } from '@ionic/core/components/ion-select-modal.js';
import { defineCustomElement as defineIonSelectOption } from '@ionic/core/components/ion-select-option.js';
import { defineCustomElement as defineIonSkeletonText } from '@ionic/core/components/ion-skeleton-text.js';
import { defineCustomElement as defineIonSpinner } from '@ionic/core/components/ion-spinner.js';
import { defineCustomElement as defineIonSplitPane } from '@ionic/core/components/ion-split-pane.js';
import { defineCustomElement as defineIonTab } from '@ionic/core/components/ion-tab.js';
import { defineCustomElement as defineIonText } from '@ionic/core/components/ion-text.js';
import { defineCustomElement as defineIonTextarea } from '@ionic/core/components/ion-textarea.js';
import { defineCustomElement as defineIonThumbnail } from '@ionic/core/components/ion-thumbnail.js';
import { defineCustomElement as defineIonTitle } from '@ionic/core/components/ion-title.js';
import { defineCustomElement as defineIonToggle } from '@ionic/core/components/ion-toggle.js';
import { defineCustomElement as defineIonToolbar } from '@ionic/core/components/ion-toolbar.js';


export const IonAccordion: StencilVueComponent<JSX.IonAccordion> = /*@__PURE__*/ defineContainer<JSX.IonAccordion>('ion-accordion', defineIonAccordion, [
  'value',
  'disabled',
  'readonly',
  'toggleIcon',
  'toggleIconSlot'
]);


export const IonAccordionGroup: StencilVueComponent<JSX.IonAccordionGroup, JSX.IonAccordionGroup["value"]> = /*@__PURE__*/ defineContainer<JSX.IonAccordionGroup, JSX.IonAccordionGroup["value"]>('ion-accordion-group', defineIonAccordionGroup, [
  'animated',
  'multiple',
  'value',
  'disabled',
  'readonly',
  'expand',
  'ionChange',
  'ionValueChange'
], [
  'ionChange',
  'ionValueChange'
],
'value', 'ion-change');


export const IonAvatar: StencilVueComponent<JSX.IonAvatar> = /*@__PURE__*/ defineContainer<JSX.IonAvatar>('ion-avatar', defineIonAvatar);


export const IonBackdrop: StencilVueComponent<JSX.IonBackdrop> = /*@__PURE__*/ defineContainer<JSX.IonBackdrop>('ion-backdrop', defineIonBackdrop, [
  'visible',
  'tappable',
  'stopPropagation',
  'ionBackdropTap'
], [
  'ionBackdropTap'
]);


export const IonBadge: StencilVueComponent<JSX.IonBadge> = /*@__PURE__*/ defineContainer<JSX.IonBadge>('ion-badge', defineIonBadge, [
  'color'
]);


export const IonBreadcrumb: StencilVueComponent<JSX.IonBreadcrumb> = /*@__PURE__*/ defineContainer<JSX.IonBreadcrumb>('ion-breadcrumb', defineIonBreadcrumb, [
  'collapsed',
  'last',
  'showCollapsedIndicator',
  'color',
  'active',
  'disabled',
  'download',
  'href',
  'rel',
  'separator',
  'target',
  'routerDirection',
  'routerAnimation',
  'ionFocus',
  'ionBlur',
  'collapsedClick'
], [
  'ionFocus',
  'ionBlur',
  'collapsedClick'
]);


export const IonBreadcrumbs: StencilVueComponent<JSX.IonBreadcrumbs> = /*@__PURE__*/ defineContainer<JSX.IonBreadcrumbs>('ion-breadcrumbs', defineIonBreadcrumbs, [
  'color',
  'maxItems',
  'itemsBeforeCollapse',
  'itemsAfterCollapse',
  'ionCollapsedClick'
], [
  'ionCollapsedClick'
]);


export const IonButton: StencilVueComponent<JSX.IonButton> = /*@__PURE__*/ defineContainer<JSX.IonButton>('ion-button', defineIonButton, [
  'color',
  'buttonType',
  'disabled',
  'expand',
  'fill',
  'routerDirection',
  'routerAnimation',
  'download',
  'href',
  'rel',
  'shape',
  'size',
  'strong',
  'target',
  'type',
  'form',
  'ionFocus',
  'ionBlur'
], [
  'ionFocus',
  'ionBlur'
]);


export const IonButtons: StencilVueComponent<JSX.IonButtons> = /*@__PURE__*/ defineContainer<JSX.IonButtons>('ion-buttons', defineIonButtons, [
  'collapse'
]);


export const IonCard: StencilVueComponent<JSX.IonCard> = /*@__PURE__*/ defineContainer<JSX.IonCard>('ion-card', defineIonCard, [
  'color',
  'button',
  'type',
  'disabled',
  'download',
  'href',
  'rel',
  'routerDirection',
  'routerAnimation',
  'target'
]);


export const IonCardContent: StencilVueComponent<JSX.IonCardContent> = /*@__PURE__*/ defineContainer<JSX.IonCardContent>('ion-card-content', defineIonCardContent);


export const IonCardHeader: StencilVueComponent<JSX.IonCardHeader> = /*@__PURE__*/ defineContainer<JSX.IonCardHeader>('ion-card-header', defineIonCardHeader, [
  'color',
  'translucent'
]);


export const IonCardSubtitle: StencilVueComponent<JSX.IonCardSubtitle> = /*@__PURE__*/ defineContainer<JSX.IonCardSubtitle>('ion-card-subtitle', defineIonCardSubtitle, [
  'color'
]);


export const IonCardTitle: StencilVueComponent<JSX.IonCardTitle> = /*@__PURE__*/ defineContainer<JSX.IonCardTitle>('ion-card-title', defineIonCardTitle, [
  'color'
]);


export const IonCheckbox: StencilVueComponent<JSX.IonCheckbox, JSX.IonCheckbox["checked"]> = /*@__PURE__*/ defineContainer<JSX.IonCheckbox, JSX.IonCheckbox["checked"]>('ion-checkbox', defineIonCheckbox, [
  'color',
  'name',
  'checked',
  'indeterminate',
  'disabled',
  'errorText',
  'helperText',
  'value',
  'labelPlacement',
  'justify',
  'alignment',
  'required',
  'ionChange',
  'ionFocus',
  'ionBlur'
], [
  'ionChange',
  'ionFocus',
  'ionBlur'
],
'checked', 'ion-change');


export const IonChip: StencilVueComponent<JSX.IonChip> = /*@__PURE__*/ defineContainer<JSX.IonChip>('ion-chip', defineIonChip, [
  'color',
  'outline',
  'disabled'
]);


export const IonCol: StencilVueComponent<JSX.IonCol> = /*@__PURE__*/ defineContainer<JSX.IonCol>('ion-col', defineIonCol, [
  'offset',
  'offsetXs',
  'offsetSm',
  'offsetMd',
  'offsetLg',
  'offsetXl',
  'pull',
  'pullXs',
  'pullSm',
  'pullMd',
  'pullLg',
  'pullXl',
  'push',
  'pushXs',
  'pushSm',
  'pushMd',
  'pushLg',
  'pushXl',
  'size',
  'sizeXs',
  'sizeSm',
  'sizeMd',
  'sizeLg',
  'sizeXl'
]);


export const IonContent: StencilVueComponent<JSX.IonContent> = /*@__PURE__*/ defineContainer<JSX.IonContent>('ion-content', defineIonContent, [
  'color',
  'fullscreen',
  'fixedSlotPlacement',
  'forceOverscroll',
  'scrollX',
  'scrollY',
  'scrollEvents',
  'ionScrollStart',
  'ionScroll',
  'ionScrollEnd'
], [
  'ionScrollStart',
  'ionScroll',
  'ionScrollEnd'
]);


export const IonDatetime: StencilVueComponent<JSX.IonDatetime, JSX.IonDatetime["value"]> = /*@__PURE__*/ defineContainer<JSX.IonDatetime, JSX.IonDatetime["value"]>('ion-datetime', defineIonDatetime, [
  'color',
  'name',
  'disabled',
  'formatOptions',
  'readonly',
  'isDateEnabled',
  'showAdjacentDays',
  'min',
  'max',
  'presentation',
  'cancelText',
  'doneText',
  'clearText',
  'yearValues',
  'monthValues',
  'dayValues',
  'hourValues',
  'minuteValues',
  'locale',
  'firstDayOfWeek',
  'titleSelectedDatesFormatter',
  'multiple',
  'highlightedDates',
  'value',
  'showDefaultTitle',
  'showDefaultButtons',
  'showClearButton',
  'showDefaultTimeLabel',
  'hourCycle',
  'size',
  'preferWheel',
  'ionCancel',
  'ionChange',
  'ionValueChange',
  'ionFocus',
  'ionBlur',
  'ionStyle',
  'ionRender'
], [
  'ionCancel',
  'ionChange',
  'ionValueChange',
  'ionFocus',
  'ionBlur',
  'ionStyle',
  'ionRender'
],
'value', 'ion-change');


export const IonDatetimeButton: StencilVueComponent<JSX.IonDatetimeButton> = /*@__PURE__*/ defineContainer<JSX.IonDatetimeButton>('ion-datetime-button', defineIonDatetimeButton, [
  'color',
  'disabled',
  'datetime'
]);


export const IonFab: StencilVueComponent<JSX.IonFab> = /*@__PURE__*/ defineContainer<JSX.IonFab>('ion-fab', defineIonFab, [
  'horizontal',
  'vertical',
  'edge',
  'activated'
]);


export const IonFabButton: StencilVueComponent<JSX.IonFabButton> = /*@__PURE__*/ defineContainer<JSX.IonFabButton>('ion-fab-button', defineIonFabButton, [
  'color',
  'activated',
  'disabled',
  'download',
  'href',
  'rel',
  'routerDirection',
  'routerAnimation',
  'target',
  'show',
  'translucent',
  'type',
  'size',
  'closeIcon',
  'ionFocus',
  'ionBlur'
], [
  'ionFocus',
  'ionBlur'
]);


export const IonFabList: StencilVueComponent<JSX.IonFabList> = /*@__PURE__*/ defineContainer<JSX.IonFabList>('ion-fab-list', defineIonFabList, [
  'activated',
  'side'
]);


export const IonFooter: StencilVueComponent<JSX.IonFooter> = /*@__PURE__*/ defineContainer<JSX.IonFooter>('ion-footer', defineIonFooter, [
  'collapse',
  'translucent'
]);


export const IonGrid: StencilVueComponent<JSX.IonGrid> = /*@__PURE__*/ defineContainer<JSX.IonGrid>('ion-grid', defineIonGrid, [
  'fixed'
]);


export const IonHeader: StencilVueComponent<JSX.IonHeader> = /*@__PURE__*/ defineContainer<JSX.IonHeader>('ion-header', defineIonHeader, [
  'collapse',
  'translucent'
]);


export const IonImg: StencilVueComponent<JSX.IonImg> = /*@__PURE__*/ defineContainer<JSX.IonImg>('ion-img', defineIonImg, [
  'alt',
  'src',
  'ionImgWillLoad',
  'ionImgDidLoad',
  'ionError'
], [
  'ionImgWillLoad',
  'ionImgDidLoad',
  'ionError'
]);


export const IonInfiniteScroll: StencilVueComponent<JSX.IonInfiniteScroll> = /*@__PURE__*/ defineContainer<JSX.IonInfiniteScroll>('ion-infinite-scroll', defineIonInfiniteScroll, [
  'threshold',
  'disabled',
  'position',
  'ionInfinite'
], [
  'ionInfinite'
]);


export const IonInfiniteScrollContent: StencilVueComponent<JSX.IonInfiniteScrollContent> = /*@__PURE__*/ defineContainer<JSX.IonInfiniteScrollContent>('ion-infinite-scroll-content', defineIonInfiniteScrollContent, [
  'loadingSpinner',
  'loadingText'
]);


export const IonInput: StencilVueComponent<JSX.IonInput, JSX.IonInput["value"]> = /*@__PURE__*/ defineContainer<JSX.IonInput, JSX.IonInput["value"]>('ion-input', defineIonInput, [
  'color',
  'autocapitalize',
  'autocomplete',
  'autocorrect',
  'autofocus',
  'clearInput',
  'clearInputIcon',
  'clearOnEdit',
  'counter',
  'counterFormatter',
  'debounce',
  'disabled',
  'enterkeyhint',
  'errorText',
  'fill',
  'inputmode',
  'helperText',
  'label',
  'labelPlacement',
  'max',
  'maxlength',
  'min',
  'minlength',
  'multiple',
  'name',
  'pattern',
  'placeholder',
  'readonly',
  'required',
  'shape',
  'spellcheck',
  'step',
  'type',
  'value',
  'ionInput',
  'ionChange',
  'ionBlur',
  'ionFocus'
], [
  'ionInput',
  'ionChange',
  'ionBlur',
  'ionFocus'
],
'value', 'ion-input');


export const IonInputOtp: StencilVueComponent<JSX.IonInputOtp, JSX.IonInputOtp["value"]> = /*@__PURE__*/ defineContainer<JSX.IonInputOtp, JSX.IonInputOtp["value"]>('ion-input-otp', defineIonInputOtp, [
  'autocapitalize',
  'color',
  'disabled',
  'fill',
  'inputmode',
  'length',
  'pattern',
  'readonly',
  'separators',
  'shape',
  'size',
  'type',
  'value',
  'ionInput',
  'ionChange',
  'ionComplete',
  'ionBlur',
  'ionFocus'
], [
  'ionInput',
  'ionChange',
  'ionComplete',
  'ionBlur',
  'ionFocus'
],
'value', 'ion-input');


export const IonInputPasswordToggle: StencilVueComponent<JSX.IonInputPasswordToggle> = /*@__PURE__*/ defineContainer<JSX.IonInputPasswordToggle>('ion-input-password-toggle', defineIonInputPasswordToggle, [
  'color',
  'showIcon',
  'hideIcon',
  'type'
]);


export const IonItem: StencilVueComponent<JSX.IonItem> = /*@__PURE__*/ defineContainer<JSX.IonItem>('ion-item', defineIonItem, [
  'color',
  'button',
  'detail',
  'detailIcon',
  'disabled',
  'download',
  'href',
  'rel',
  'lines',
  'routerAnimation',
  'routerDirection',
  'target',
  'type'
]);


export const IonItemDivider: StencilVueComponent<JSX.IonItemDivider> = /*@__PURE__*/ defineContainer<JSX.IonItemDivider>('ion-item-divider', defineIonItemDivider, [
  'color',
  'sticky'
]);


export const IonItemGroup: StencilVueComponent<JSX.IonItemGroup> = /*@__PURE__*/ defineContainer<JSX.IonItemGroup>('ion-item-group', defineIonItemGroup);


export const IonItemOption: StencilVueComponent<JSX.IonItemOption> = /*@__PURE__*/ defineContainer<JSX.IonItemOption>('ion-item-option', defineIonItemOption, [
  'color',
  'disabled',
  'download',
  'expandable',
  'href',
  'rel',
  'target',
  'type'
]);


export const IonItemOptions: StencilVueComponent<JSX.IonItemOptions> = /*@__PURE__*/ defineContainer<JSX.IonItemOptions>('ion-item-options', defineIonItemOptions, [
  'side',
  'ionSwipe'
], [
  'ionSwipe'
]);


export const IonItemSliding: StencilVueComponent<JSX.IonItemSliding> = /*@__PURE__*/ defineContainer<JSX.IonItemSliding>('ion-item-sliding', defineIonItemSliding, [
  'disabled',
  'ionDrag'
], [
  'ionDrag'
]);


export const IonLabel: StencilVueComponent<JSX.IonLabel> = /*@__PURE__*/ defineContainer<JSX.IonLabel>('ion-label', defineIonLabel, [
  'color',
  'position',
  'ionColor',
  'ionStyle'
], [
  'ionColor',
  'ionStyle'
]);


export const IonList: StencilVueComponent<JSX.IonList> = /*@__PURE__*/ defineContainer<JSX.IonList>('ion-list', defineIonList, [
  'lines',
  'inset'
]);


export const IonListHeader: StencilVueComponent<JSX.IonListHeader> = /*@__PURE__*/ defineContainer<JSX.IonListHeader>('ion-list-header', defineIonListHeader, [
  'color',
  'lines'
]);


export const IonMenu: StencilVueComponent<JSX.IonMenu> = /*@__PURE__*/ defineContainer<JSX.IonMenu>('ion-menu', defineIonMenu, [
  'contentId',
  'menuId',
  'type',
  'disabled',
  'side',
  'swipeGesture',
  'maxEdgeStart',
  'ionWillOpen',
  'ionWillClose',
  'ionDidOpen',
  'ionDidClose',
  'ionMenuChange'
], [
  'ionWillOpen',
  'ionWillClose',
  'ionDidOpen',
  'ionDidClose',
  'ionMenuChange'
]);


export const IonMenuButton: StencilVueComponent<JSX.IonMenuButton> = /*@__PURE__*/ defineContainer<JSX.IonMenuButton>('ion-menu-button', defineIonMenuButton, [
  'color',
  'disabled',
  'menu',
  'autoHide',
  'type'
]);


export const IonMenuToggle: StencilVueComponent<JSX.IonMenuToggle> = /*@__PURE__*/ defineContainer<JSX.IonMenuToggle>('ion-menu-toggle', defineIonMenuToggle, [
  'menu',
  'autoHide'
]);


export const IonNav: StencilVueComponent<JSX.IonNav> = /*@__PURE__*/ defineContainer<JSX.IonNav>('ion-nav', defineIonNav, [
  'delegate',
  'swipeGesture',
  'animated',
  'animation',
  'rootParams',
  'root',
  'ionNavWillLoad',
  'ionNavWillChange',
  'ionNavDidChange'
], [
  'ionNavWillLoad',
  'ionNavWillChange',
  'ionNavDidChange'
]);


export const IonNavLink: StencilVueComponent<JSX.IonNavLink> = /*@__PURE__*/ defineContainer<JSX.IonNavLink>('ion-nav-link', defineIonNavLink, [
  'component',
  'componentProps',
  'routerDirection',
  'routerAnimation'
]);


export const IonNote: StencilVueComponent<JSX.IonNote> = /*@__PURE__*/ defineContainer<JSX.IonNote>('ion-note', defineIonNote, [
  'color'
]);


export const IonPicker: StencilVueComponent<JSX.IonPicker> = /*@__PURE__*/ defineContainer<JSX.IonPicker>('ion-picker', defineIonPicker, [
  'ionInputModeChange'
], [
  'ionInputModeChange'
]);


export const IonPickerColumn: StencilVueComponent<JSX.IonPickerColumn> = /*@__PURE__*/ defineContainer<JSX.IonPickerColumn>('ion-picker-column', defineIonPickerColumn, [
  'disabled',
  'value',
  'color',
  'numericInput',
  'ionChange'
], [
  'ionChange'
]);


export const IonPickerColumnOption: StencilVueComponent<JSX.IonPickerColumnOption> = /*@__PURE__*/ defineContainer<JSX.IonPickerColumnOption>('ion-picker-column-option', defineIonPickerColumnOption, [
  'disabled',
  'value',
  'color'
]);


export const IonProgressBar: StencilVueComponent<JSX.IonProgressBar> = /*@__PURE__*/ defineContainer<JSX.IonProgressBar>('ion-progress-bar', defineIonProgressBar, [
  'type',
  'reversed',
  'value',
  'buffer',
  'color'
]);


export const IonRadio: StencilVueComponent<JSX.IonRadio, JSX.IonRadio["value"]> = /*@__PURE__*/ defineContainer<JSX.IonRadio, JSX.IonRadio["value"]>('ion-radio', defineIonRadio, [
  'color',
  'name',
  'disabled',
  'value',
  'labelPlacement',
  'justify',
  'alignment',
  'ionFocus',
  'ionBlur'
], [
  'ionFocus',
  'ionBlur'
],
'value', 'ion-change');


export const IonRadioGroup: StencilVueComponent<JSX.IonRadioGroup, JSX.IonRadioGroup["value"]> = /*@__PURE__*/ defineContainer<JSX.IonRadioGroup, JSX.IonRadioGroup["value"]>('ion-radio-group', defineIonRadioGroup, [
  'allowEmptySelection',
  'compareWith',
  'name',
  'value',
  'helperText',
  'errorText',
  'ionChange',
  'ionValueChange'
], [
  'ionChange',
  'ionValueChange'
],
'value', 'ion-change');


export const IonRange: StencilVueComponent<JSX.IonRange, JSX.IonRange["value"]> = /*@__PURE__*/ defineContainer<JSX.IonRange, JSX.IonRange["value"]>('ion-range', defineIonRange, [
  'color',
  'debounce',
  'name',
  'label',
  'dualKnobs',
  'min',
  'max',
  'pin',
  'pinFormatter',
  'snaps',
  'step',
  'ticks',
  'activeBarStart',
  'disabled',
  'value',
  'labelPlacement',
  'ionChange',
  'ionInput',
  'ionFocus',
  'ionBlur',
  'ionKnobMoveStart',
  'ionKnobMoveEnd'
], [
  'ionChange',
  'ionInput',
  'ionFocus',
  'ionBlur',
  'ionKnobMoveStart',
  'ionKnobMoveEnd'
],
'value', 'ion-input');


export const IonRefresher: StencilVueComponent<JSX.IonRefresher> = /*@__PURE__*/ defineContainer<JSX.IonRefresher>('ion-refresher', defineIonRefresher, [
  'pullMin',
  'pullMax',
  'closeDuration',
  'snapbackDuration',
  'pullFactor',
  'disabled',
  'ionRefresh',
  'ionPull',
  'ionStart'
], [
  'ionRefresh',
  'ionPull',
  'ionStart'
]);


export const IonRefresherContent: StencilVueComponent<JSX.IonRefresherContent> = /*@__PURE__*/ defineContainer<JSX.IonRefresherContent>('ion-refresher-content', defineIonRefresherContent, [
  'pullingIcon',
  'pullingText',
  'refreshingSpinner',
  'refreshingText'
]);


export const IonReorder: StencilVueComponent<JSX.IonReorder> = /*@__PURE__*/ defineContainer<JSX.IonReorder>('ion-reorder', defineIonReorder);


export const IonReorderGroup: StencilVueComponent<JSX.IonReorderGroup> = /*@__PURE__*/ defineContainer<JSX.IonReorderGroup>('ion-reorder-group', defineIonReorderGroup, [
  'disabled',
  'ionItemReorder',
  'ionReorderStart',
  'ionReorderMove',
  'ionReorderEnd'
], [
  'ionItemReorder',
  'ionReorderStart',
  'ionReorderMove',
  'ionReorderEnd'
]);


export const IonRippleEffect: StencilVueComponent<JSX.IonRippleEffect> = /*@__PURE__*/ defineContainer<JSX.IonRippleEffect>('ion-ripple-effect', defineIonRippleEffect, [
  'type'
]);


export const IonRow: StencilVueComponent<JSX.IonRow> = /*@__PURE__*/ defineContainer<JSX.IonRow>('ion-row', defineIonRow);


export const IonSearchbar: StencilVueComponent<JSX.IonSearchbar, JSX.IonSearchbar["value"]> = /*@__PURE__*/ defineContainer<JSX.IonSearchbar, JSX.IonSearchbar["value"]>('ion-searchbar', defineIonSearchbar, [
  'color',
  'animated',
  'autocapitalize',
  'autocomplete',
  'autocorrect',
  'cancelButtonIcon',
  'cancelButtonText',
  'clearIcon',
  'debounce',
  'disabled',
  'inputmode',
  'enterkeyhint',
  'maxlength',
  'minlength',
  'name',
  'placeholder',
  'searchIcon',
  'showCancelButton',
  'showClearButton',
  'spellcheck',
  'type',
  'value',
  'ionInput',
  'ionChange',
  'ionCancel',
  'ionClear',
  'ionBlur',
  'ionFocus',
  'ionStyle'
], [
  'ionInput',
  'ionChange',
  'ionCancel',
  'ionClear',
  'ionBlur',
  'ionFocus',
  'ionStyle'
],
'value', 'ion-input');


export const IonSegment: StencilVueComponent<JSX.IonSegment, JSX.IonSegment["value"]> = /*@__PURE__*/ defineContainer<JSX.IonSegment, JSX.IonSegment["value"]>('ion-segment', defineIonSegment, [
  'color',
  'disabled',
  'scrollable',
  'swipeGesture',
  'value',
  'selectOnFocus',
  'ionChange',
  'ionSelect',
  'ionStyle'
], [
  'ionChange',
  'ionSelect',
  'ionStyle'
],
'value', 'ion-change');


export const IonSegmentButton: StencilVueComponent<JSX.IonSegmentButton, JSX.IonSegmentButton["value"]> = /*@__PURE__*/ defineContainer<JSX.IonSegmentButton, JSX.IonSegmentButton["value"]>('ion-segment-button', defineIonSegmentButton, [
  'contentId',
  'disabled',
  'layout',
  'type',
  'value'
], [],
'value', 'ion-change');


export const IonSegmentContent: StencilVueComponent<JSX.IonSegmentContent> = /*@__PURE__*/ defineContainer<JSX.IonSegmentContent>('ion-segment-content', defineIonSegmentContent);


export const IonSegmentView: StencilVueComponent<JSX.IonSegmentView> = /*@__PURE__*/ defineContainer<JSX.IonSegmentView>('ion-segment-view', defineIonSegmentView, [
  'disabled',
  'ionSegmentViewScroll'
], [
  'ionSegmentViewScroll'
]);


export const IonSelect: StencilVueComponent<JSX.IonSelect, JSX.IonSelect["value"]> = /*@__PURE__*/ defineContainer<JSX.IonSelect, JSX.IonSelect["value"]>('ion-select', defineIonSelect, [
  'cancelText',
  'color',
  'compareWith',
  'disabled',
  'fill',
  'errorText',
  'helperText',
  'interface',
  'interfaceOptions',
  'justify',
  'label',
  'labelPlacement',
  'multiple',
  'name',
  'okText',
  'placeholder',
  'selectedText',
  'toggleIcon',
  'expandedIcon',
  'shape',
  'value',
  'required',
  'ionChange',
  'ionCancel',
  'ionDismiss',
  'ionFocus',
  'ionBlur',
  'ionStyle'
], [
  'ionChange',
  'ionCancel',
  'ionDismiss',
  'ionFocus',
  'ionBlur',
  'ionStyle'
],
'value', 'ion-change');


export const IonSelectModal: StencilVueComponent<JSX.IonSelectModal> = /*@__PURE__*/ defineContainer<JSX.IonSelectModal>('ion-select-modal', defineIonSelectModal, [
  'header',
  'multiple',
  'options'
]);


export const IonSelectOption: StencilVueComponent<JSX.IonSelectOption> = /*@__PURE__*/ defineContainer<JSX.IonSelectOption>('ion-select-option', defineIonSelectOption, [
  'disabled',
  'value'
]);


export const IonSkeletonText: StencilVueComponent<JSX.IonSkeletonText> = /*@__PURE__*/ defineContainer<JSX.IonSkeletonText>('ion-skeleton-text', defineIonSkeletonText, [
  'animated',
  'ionStyle'
], [
  'ionStyle'
]);


export const IonSpinner: StencilVueComponent<JSX.IonSpinner> = /*@__PURE__*/ defineContainer<JSX.IonSpinner>('ion-spinner', defineIonSpinner, [
  'color',
  'duration',
  'name',
  'paused'
]);


export const IonSplitPane: StencilVueComponent<JSX.IonSplitPane> = /*@__PURE__*/ defineContainer<JSX.IonSplitPane>('ion-split-pane', defineIonSplitPane, [
  'contentId',
  'disabled',
  'when',
  'ionSplitPaneVisible'
], [
  'ionSplitPaneVisible'
]);


export const IonTab: StencilVueComponent<JSX.IonTab> = /*@__PURE__*/ defineContainer<JSX.IonTab>('ion-tab', defineIonTab, [
  'active',
  'delegate',
  'tab',
  'component'
]);


export const IonText: StencilVueComponent<JSX.IonText> = /*@__PURE__*/ defineContainer<JSX.IonText>('ion-text', defineIonText, [
  'color'
]);


export const IonTextarea: StencilVueComponent<JSX.IonTextarea, JSX.IonTextarea["value"]> = /*@__PURE__*/ defineContainer<JSX.IonTextarea, JSX.IonTextarea["value"]>('ion-textarea', defineIonTextarea, [
  'color',
  'autocapitalize',
  'autofocus',
  'clearOnEdit',
  'debounce',
  'disabled',
  'fill',
  'inputmode',
  'enterkeyhint',
  'maxlength',
  'minlength',
  'name',
  'placeholder',
  'readonly',
  'required',
  'spellcheck',
  'cols',
  'rows',
  'wrap',
  'autoGrow',
  'value',
  'counter',
  'counterFormatter',
  'errorText',
  'helperText',
  'label',
  'labelPlacement',
  'shape',
  'ionChange',
  'ionInput',
  'ionBlur',
  'ionFocus'
], [
  'ionChange',
  'ionInput',
  'ionBlur',
  'ionFocus'
],
'value', 'ion-input');


export const IonThumbnail: StencilVueComponent<JSX.IonThumbnail> = /*@__PURE__*/ defineContainer<JSX.IonThumbnail>('ion-thumbnail', defineIonThumbnail);


export const IonTitle: StencilVueComponent<JSX.IonTitle> = /*@__PURE__*/ defineContainer<JSX.IonTitle>('ion-title', defineIonTitle, [
  'color',
  'size',
  'ionStyle'
], [
  'ionStyle'
]);


export const IonToggle: StencilVueComponent<JSX.IonToggle, JSX.IonToggle["checked"]> = /*@__PURE__*/ defineContainer<JSX.IonToggle, JSX.IonToggle["checked"]>('ion-toggle', defineIonToggle, [
  'color',
  'name',
  'checked',
  'disabled',
  'errorText',
  'helperText',
  'value',
  'enableOnOffLabels',
  'labelPlacement',
  'justify',
  'alignment',
  'required',
  'ionChange',
  'ionFocus',
  'ionBlur'
], [
  'ionChange',
  'ionFocus',
  'ionBlur'
],
'checked', 'ion-change');


export const IonToolbar: StencilVueComponent<JSX.IonToolbar> = /*@__PURE__*/ defineContainer<JSX.IonToolbar>('ion-toolbar', defineIonToolbar, [
  'color'
]);