/* eslint-disable */
/* tslint:disable */
/* auto-generated vue proxies */
import { defineContainer } from './vue-component-lib/utils';

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




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


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


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


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


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


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


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


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


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


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


export const IonCheckbox = /*@__PURE__*/ defineContainer<JSX.IonCheckbox>('ion-checkbox', [
  'color',
  'name',
  'checked',
  'indeterminate',
  'disabled',
  'value',
  'ionChange',
  'ionFocus',
  'ionBlur',
  'ionStyle'
],
{
  "modelProp": "checked",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


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


export const IonCol = /*@__PURE__*/ defineContainer<JSX.IonCol>('ion-col', [
  '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 = /*@__PURE__*/ defineContainer<JSX.IonContent>('ion-content', [
  'color',
  'fullscreen',
  'forceOverscroll',
  'scrollX',
  'scrollY',
  'scrollEvents',
  'ionScrollStart',
  'ionScroll',
  'ionScrollEnd'
]);


export const IonDatetime = /*@__PURE__*/ defineContainer<JSX.IonDatetime>('ion-datetime', [
  'name',
  'disabled',
  'readonly',
  'min',
  'max',
  'displayFormat',
  'displayTimezone',
  'pickerFormat',
  'cancelText',
  'doneText',
  'yearValues',
  'monthValues',
  'dayValues',
  'hourValues',
  'minuteValues',
  'monthNames',
  'monthShortNames',
  'dayNames',
  'dayShortNames',
  'pickerOptions',
  'placeholder',
  'value',
  'ionCancel',
  'ionChange',
  'ionFocus',
  'ionBlur',
  'ionStyle'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


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


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


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


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


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


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


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


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


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


export const IonInput = /*@__PURE__*/ defineContainer<JSX.IonInput>('ion-input', [
  'fireFocusEvents',
  'color',
  'accept',
  'autocapitalize',
  'autocomplete',
  'autocorrect',
  'autofocus',
  'clearInput',
  'clearOnEdit',
  'debounce',
  'disabled',
  'enterkeyhint',
  'inputmode',
  'max',
  'maxlength',
  'min',
  'minlength',
  'multiple',
  'name',
  'pattern',
  'placeholder',
  'readonly',
  'required',
  'spellcheck',
  'step',
  'size',
  'type',
  'value',
  'ionInput',
  'ionChange',
  'ionBlur',
  'ionFocus',
  'ionStyle'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


export const IonRadio = /*@__PURE__*/ defineContainer<JSX.IonRadio>('ion-radio', [
  'color',
  'name',
  'disabled',
  'value',
  'ionStyle',
  'ionFocus',
  'ionBlur'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


export const IonRadioGroup = /*@__PURE__*/ defineContainer<JSX.IonRadioGroup>('ion-radio-group', [
  'allowEmptySelection',
  'name',
  'value',
  'ionChange'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


export const IonRange = /*@__PURE__*/ defineContainer<JSX.IonRange>('ion-range', [
  'color',
  'debounce',
  'name',
  'dualKnobs',
  'min',
  'max',
  'pin',
  'snaps',
  'step',
  'ticks',
  'disabled',
  'value',
  'ionChange',
  'ionStyle',
  'ionFocus',
  'ionBlur'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


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


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


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


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


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


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


export const IonSearchbar = /*@__PURE__*/ defineContainer<JSX.IonSearchbar>('ion-searchbar', [
  'color',
  'animated',
  'autocomplete',
  'autocorrect',
  'cancelButtonIcon',
  'cancelButtonText',
  'clearIcon',
  'debounce',
  'disabled',
  'inputmode',
  'enterkeyhint',
  'placeholder',
  'searchIcon',
  'showCancelButton',
  'spellcheck',
  'type',
  'value',
  'ionInput',
  'ionChange',
  'ionCancel',
  'ionClear',
  'ionBlur',
  'ionFocus',
  'ionStyle'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


export const IonSegment = /*@__PURE__*/ defineContainer<JSX.IonSegment>('ion-segment', [
  'color',
  'disabled',
  'scrollable',
  'swipeGesture',
  'value',
  'ionChange',
  'ionSelect',
  'ionStyle'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


export const IonSegmentButton = /*@__PURE__*/ defineContainer<JSX.IonSegmentButton>('ion-segment-button', [
  'disabled',
  'layout',
  'type',
  'value'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


export const IonSelect = /*@__PURE__*/ defineContainer<JSX.IonSelect>('ion-select', [
  'disabled',
  'cancelText',
  'okText',
  'placeholder',
  'name',
  'selectedText',
  'multiple',
  'interface',
  'interfaceOptions',
  'compareWith',
  'value',
  'ionChange',
  'ionCancel',
  'ionFocus',
  'ionBlur',
  'ionStyle'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


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


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


export const IonSlide = /*@__PURE__*/ defineContainer<JSX.IonSlide>('ion-slide');


export const IonSlides = /*@__PURE__*/ defineContainer<JSX.IonSlides>('ion-slides', [
  'options',
  'pager',
  'scrollbar',
  'ionSlidesDidLoad',
  'ionSlideTap',
  'ionSlideDoubleTap',
  'ionSlideWillChange',
  'ionSlideDidChange',
  'ionSlideNextStart',
  'ionSlidePrevStart',
  'ionSlideNextEnd',
  'ionSlidePrevEnd',
  'ionSlideTransitionStart',
  'ionSlideTransitionEnd',
  'ionSlideDrag',
  'ionSlideReachStart',
  'ionSlideReachEnd',
  'ionSlideTouchStart',
  'ionSlideTouchEnd'
]);


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


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


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


export const IonTextarea = /*@__PURE__*/ defineContainer<JSX.IonTextarea>('ion-textarea', [
  'fireFocusEvents',
  'color',
  'autocapitalize',
  'autofocus',
  'clearOnEdit',
  'debounce',
  'disabled',
  'inputmode',
  'enterkeyhint',
  'maxlength',
  'minlength',
  'name',
  'placeholder',
  'readonly',
  'required',
  'spellcheck',
  'cols',
  'rows',
  'wrap',
  'autoGrow',
  'value',
  'ionChange',
  'ionInput',
  'ionStyle',
  'ionBlur',
  'ionFocus'
],
{
  "modelProp": "value",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


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


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


export const IonToggle = /*@__PURE__*/ defineContainer<JSX.IonToggle>('ion-toggle', [
  'color',
  'name',
  'checked',
  'disabled',
  'value',
  'ionChange',
  'ionFocus',
  'ionBlur',
  'ionStyle'
],
{
  "modelProp": "checked",
  "modelUpdateEvent": "v-ionChange",
  "externalModelUpdateEvent": "ionChange"
});


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


export const IonVirtualScroll = /*@__PURE__*/ defineContainer<JSX.IonVirtualScroll>('ion-virtual-scroll', [
  'approxItemHeight',
  'approxHeaderHeight',
  'approxFooterHeight',
  'headerFn',
  'footerFn',
  'items',
  'itemHeight',
  'headerHeight',
  'footerHeight',
  'renderItem',
  'renderHeader',
  'renderFooter',
  'nodeRender',
  'domRender'
]);

