'use client';

/**
 * This file was automatically generated by the Stencil React Output Target.
 * Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
 */

/* eslint-disable */

import type { EventName, StencilReactComponent } from '@stencil/react-output-target/runtime';
import { createComponent } from '@stencil/react-output-target/runtime';
import { type AccordionChangeEventType, type AccordionGroupChangeEventType, type BcmAccordionCustomEvent, type BcmAccordionGroupCustomEvent, type BcmAlertCustomEvent, type BcmButtonCustomEvent, type BcmCheckboxCustomEvent, type BcmChipCustomEvent, type BcmDrawerCustomEvent, type BcmDropdownCustomEvent, type BcmDropdownItemCustomEvent, type BcmFileUploadCustomEvent, type BcmInputCustomEvent, type BcmLinkedCustomEvent, type BcmModalCustomEvent, type BcmPopConfirmCustomEvent, type BcmPopoverCustomEvent, type BcmRadioCustomEvent, type BcmRadioGroupCustomEvent, type BcmSegmentCustomEvent, type BcmSegmentedPickerCustomEvent, type BcmSwitchCustomEvent, type BcmTabCustomEvent, type BcmTabsCustomEvent, type BcmTextareaCustomEvent, type BcmUploadItem } from "bromcom-ui-next";
import { BcmAccordionGroup as BcmAccordionGroupElement, defineCustomElement as defineBcmAccordionGroup } from "bromcom-ui-next/dist/components/bcm-accordion-group.js";
import { BcmAccordion as BcmAccordionElement, defineCustomElement as defineBcmAccordion } from "bromcom-ui-next/dist/components/bcm-accordion.js";
import { BcmAlert as BcmAlertElement, defineCustomElement as defineBcmAlert } from "bromcom-ui-next/dist/components/bcm-alert.js";
import { BcmAttendance as BcmAttendanceElement, defineCustomElement as defineBcmAttendance } from "bromcom-ui-next/dist/components/bcm-attendance.js";
import { BcmAvatar as BcmAvatarElement, defineCustomElement as defineBcmAvatar } from "bromcom-ui-next/dist/components/bcm-avatar.js";
import { BcmBadge as BcmBadgeElement, defineCustomElement as defineBcmBadge } from "bromcom-ui-next/dist/components/bcm-badge.js";
import { BcmBasicBadge as BcmBasicBadgeElement, defineCustomElement as defineBcmBasicBadge } from "bromcom-ui-next/dist/components/bcm-basic-badge.js";
import { BcmButtonGroup as BcmButtonGroupElement, defineCustomElement as defineBcmButtonGroup } from "bromcom-ui-next/dist/components/bcm-button-group.js";
import { BcmButton as BcmButtonElement, defineCustomElement as defineBcmButton } from "bromcom-ui-next/dist/components/bcm-button.js";
import { BcmCheckbox as BcmCheckboxElement, defineCustomElement as defineBcmCheckbox } from "bromcom-ui-next/dist/components/bcm-checkbox.js";
import { BcmChip as BcmChipElement, defineCustomElement as defineBcmChip } from "bromcom-ui-next/dist/components/bcm-chip.js";
import { BcmDivider as BcmDividerElement, defineCustomElement as defineBcmDivider } from "bromcom-ui-next/dist/components/bcm-divider.js";
import { BcmDrawer as BcmDrawerElement, defineCustomElement as defineBcmDrawer } from "bromcom-ui-next/dist/components/bcm-drawer.js";
import { BcmDropdownItem as BcmDropdownItemElement, defineCustomElement as defineBcmDropdownItem } from "bromcom-ui-next/dist/components/bcm-dropdown-item.js";
import { BcmDropdown as BcmDropdownElement, defineCustomElement as defineBcmDropdown } from "bromcom-ui-next/dist/components/bcm-dropdown.js";
import { BcmFileUpload as BcmFileUploadElement, defineCustomElement as defineBcmFileUpload } from "bromcom-ui-next/dist/components/bcm-file-upload.js";
import { BcmInput as BcmInputElement, defineCustomElement as defineBcmInput } from "bromcom-ui-next/dist/components/bcm-input.js";
import { BcmLinked as BcmLinkedElement, defineCustomElement as defineBcmLinked } from "bromcom-ui-next/dist/components/bcm-linked.js";
import { BcmModal as BcmModalElement, defineCustomElement as defineBcmModal } from "bromcom-ui-next/dist/components/bcm-modal.js";
import { BcmPopConfirm as BcmPopConfirmElement, defineCustomElement as defineBcmPopConfirm } from "bromcom-ui-next/dist/components/bcm-pop-confirm.js";
import { BcmPopover as BcmPopoverElement, defineCustomElement as defineBcmPopover } from "bromcom-ui-next/dist/components/bcm-popover.js";
import { BcmRadioGroup as BcmRadioGroupElement, defineCustomElement as defineBcmRadioGroup } from "bromcom-ui-next/dist/components/bcm-radio-group.js";
import { BcmRadio as BcmRadioElement, defineCustomElement as defineBcmRadio } from "bromcom-ui-next/dist/components/bcm-radio.js";
import { BcmSegment as BcmSegmentElement, defineCustomElement as defineBcmSegment } from "bromcom-ui-next/dist/components/bcm-segment.js";
import { BcmSegmentedPicker as BcmSegmentedPickerElement, defineCustomElement as defineBcmSegmentedPicker } from "bromcom-ui-next/dist/components/bcm-segmented-picker.js";
import { BcmShortcut as BcmShortcutElement, defineCustomElement as defineBcmShortcut } from "bromcom-ui-next/dist/components/bcm-shortcut.js";
import { BcmSwitch as BcmSwitchElement, defineCustomElement as defineBcmSwitch } from "bromcom-ui-next/dist/components/bcm-switch.js";
import { BcmTab as BcmTabElement, defineCustomElement as defineBcmTab } from "bromcom-ui-next/dist/components/bcm-tab.js";
import { BcmTabs as BcmTabsElement, defineCustomElement as defineBcmTabs } from "bromcom-ui-next/dist/components/bcm-tabs.js";
import { BcmText as BcmTextElement, defineCustomElement as defineBcmText } from "bromcom-ui-next/dist/components/bcm-text.js";
import { BcmTextarea as BcmTextareaElement, defineCustomElement as defineBcmTextarea } from "bromcom-ui-next/dist/components/bcm-textarea.js";
import { BcmTooltip as BcmTooltipElement, defineCustomElement as defineBcmTooltip } from "bromcom-ui-next/dist/components/bcm-tooltip.js";
import React from 'react';

export type BcmAccordionEvents = { onBcmAccordionChange: EventName<BcmAccordionCustomEvent<AccordionChangeEventType>> };

export const BcmAccordion: StencilReactComponent<BcmAccordionElement, BcmAccordionEvents> = /*@__PURE__*/ createComponent<BcmAccordionElement, BcmAccordionEvents>({
    tagName: 'bcm-accordion',
    elementClass: BcmAccordionElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmAccordionChange: 'bcmAccordionChange' } as BcmAccordionEvents,
    defineCustomElement: defineBcmAccordion
});

export type BcmAccordionGroupEvents = { onBcmAccordionGroupChange: EventName<BcmAccordionGroupCustomEvent<AccordionGroupChangeEventType>> };

export const BcmAccordionGroup: StencilReactComponent<BcmAccordionGroupElement, BcmAccordionGroupEvents> = /*@__PURE__*/ createComponent<BcmAccordionGroupElement, BcmAccordionGroupEvents>({
    tagName: 'bcm-accordion-group',
    elementClass: BcmAccordionGroupElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmAccordionGroupChange: 'bcmAccordionGroupChange' } as BcmAccordionGroupEvents,
    defineCustomElement: defineBcmAccordionGroup
});

export type BcmAlertEvents = { onBcmDismiss: EventName<BcmAlertCustomEvent<void>> };

export const BcmAlert: StencilReactComponent<BcmAlertElement, BcmAlertEvents> = /*@__PURE__*/ createComponent<BcmAlertElement, BcmAlertEvents>({
    tagName: 'bcm-alert',
    elementClass: BcmAlertElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmDismiss: 'bcmDismiss' } as BcmAlertEvents,
    defineCustomElement: defineBcmAlert
});

export type BcmAttendanceEvents = NonNullable<unknown>;

export const BcmAttendance: StencilReactComponent<BcmAttendanceElement, BcmAttendanceEvents> = /*@__PURE__*/ createComponent<BcmAttendanceElement, BcmAttendanceEvents>({
    tagName: 'bcm-attendance',
    elementClass: BcmAttendanceElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmAttendanceEvents,
    defineCustomElement: defineBcmAttendance
});

export type BcmAvatarEvents = NonNullable<unknown>;

export const BcmAvatar: StencilReactComponent<BcmAvatarElement, BcmAvatarEvents> = /*@__PURE__*/ createComponent<BcmAvatarElement, BcmAvatarEvents>({
    tagName: 'bcm-avatar',
    elementClass: BcmAvatarElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmAvatarEvents,
    defineCustomElement: defineBcmAvatar
});

export type BcmBadgeEvents = NonNullable<unknown>;

export const BcmBadge: StencilReactComponent<BcmBadgeElement, BcmBadgeEvents> = /*@__PURE__*/ createComponent<BcmBadgeElement, BcmBadgeEvents>({
    tagName: 'bcm-badge',
    elementClass: BcmBadgeElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmBadgeEvents,
    defineCustomElement: defineBcmBadge
});

export type BcmBasicBadgeEvents = NonNullable<unknown>;

export const BcmBasicBadge: StencilReactComponent<BcmBasicBadgeElement, BcmBasicBadgeEvents> = /*@__PURE__*/ createComponent<BcmBasicBadgeElement, BcmBasicBadgeEvents>({
    tagName: 'bcm-basic-badge',
    elementClass: BcmBasicBadgeElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmBasicBadgeEvents,
    defineCustomElement: defineBcmBasicBadge
});

export type BcmButtonEvents = {
    onBcmClick: EventName<BcmButtonCustomEvent<MouseEvent>>,
    onBcmFocus: EventName<BcmButtonCustomEvent<FocusEvent>>,
    onBcmBlur: EventName<BcmButtonCustomEvent<FocusEvent>>
};

export const BcmButton: StencilReactComponent<BcmButtonElement, BcmButtonEvents> = /*@__PURE__*/ createComponent<BcmButtonElement, BcmButtonEvents>({
    tagName: 'bcm-button',
    elementClass: BcmButtonElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmClick: 'bcmClick',
        onBcmFocus: 'bcmFocus',
        onBcmBlur: 'bcmBlur'
    } as BcmButtonEvents,
    defineCustomElement: defineBcmButton
});

export type BcmButtonGroupEvents = NonNullable<unknown>;

export const BcmButtonGroup: StencilReactComponent<BcmButtonGroupElement, BcmButtonGroupEvents> = /*@__PURE__*/ createComponent<BcmButtonGroupElement, BcmButtonGroupEvents>({
    tagName: 'bcm-button-group',
    elementClass: BcmButtonGroupElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmButtonGroupEvents,
    defineCustomElement: defineBcmButtonGroup
});

export type BcmCheckboxEvents = { onBcmCheckboxChange: EventName<BcmCheckboxCustomEvent<{ element: HTMLInputElement; checked: boolean }>> };

export const BcmCheckbox: StencilReactComponent<BcmCheckboxElement, BcmCheckboxEvents> = /*@__PURE__*/ createComponent<BcmCheckboxElement, BcmCheckboxEvents>({
    tagName: 'bcm-checkbox',
    elementClass: BcmCheckboxElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmCheckboxChange: 'bcmCheckboxChange' } as BcmCheckboxEvents,
    defineCustomElement: defineBcmCheckbox
});

export type BcmChipEvents = { onBcmDismiss: EventName<BcmChipCustomEvent<void>> };

export const BcmChip: StencilReactComponent<BcmChipElement, BcmChipEvents> = /*@__PURE__*/ createComponent<BcmChipElement, BcmChipEvents>({
    tagName: 'bcm-chip',
    elementClass: BcmChipElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmDismiss: 'bcmDismiss' } as BcmChipEvents,
    defineCustomElement: defineBcmChip
});

export type BcmDividerEvents = NonNullable<unknown>;

export const BcmDivider: StencilReactComponent<BcmDividerElement, BcmDividerEvents> = /*@__PURE__*/ createComponent<BcmDividerElement, BcmDividerEvents>({
    tagName: 'bcm-divider',
    elementClass: BcmDividerElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmDividerEvents,
    defineCustomElement: defineBcmDivider
});

export type BcmDrawerEvents = {
    onBcmOpen: EventName<BcmDrawerCustomEvent<void>>,
    onBcmClose: EventName<BcmDrawerCustomEvent<void>>,
    onBcmBeforeOpen: EventName<BcmDrawerCustomEvent<void>>,
    onBcmBeforeClose: EventName<BcmDrawerCustomEvent<void>>
};

export const BcmDrawer: StencilReactComponent<BcmDrawerElement, BcmDrawerEvents> = /*@__PURE__*/ createComponent<BcmDrawerElement, BcmDrawerEvents>({
    tagName: 'bcm-drawer',
    elementClass: BcmDrawerElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmOpen: 'bcmOpen',
        onBcmClose: 'bcmClose',
        onBcmBeforeOpen: 'bcmBeforeOpen',
        onBcmBeforeClose: 'bcmBeforeClose'
    } as BcmDrawerEvents,
    defineCustomElement: defineBcmDrawer
});

export type BcmDropdownEvents = { onBcmDropdownChange: EventName<BcmDropdownCustomEvent<any>> };

export const BcmDropdown: StencilReactComponent<BcmDropdownElement, BcmDropdownEvents> = /*@__PURE__*/ createComponent<BcmDropdownElement, BcmDropdownEvents>({
    tagName: 'bcm-dropdown',
    elementClass: BcmDropdownElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmDropdownChange: 'bcmDropdownChange' } as BcmDropdownEvents,
    defineCustomElement: defineBcmDropdown
});

export type BcmDropdownItemEvents = { onBcmDropDownItemChange: EventName<BcmDropdownItemCustomEvent<any>> };

export const BcmDropdownItem: StencilReactComponent<BcmDropdownItemElement, BcmDropdownItemEvents> = /*@__PURE__*/ createComponent<BcmDropdownItemElement, BcmDropdownItemEvents>({
    tagName: 'bcm-dropdown-item',
    elementClass: BcmDropdownItemElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmDropDownItemChange: 'bcmDropDownItemChange' } as BcmDropdownItemEvents,
    defineCustomElement: defineBcmDropdownItem
});

export type BcmFileUploadEvents = {
    onBcmFileChange: EventName<BcmFileUploadCustomEvent<File[]>>,
    onBcmFileRemoved: EventName<BcmFileUploadCustomEvent<BcmUploadItem>>,
    onBcmUploadCanceled: EventName<BcmFileUploadCustomEvent<BcmUploadItem>>,
    onBcmFocus: EventName<BcmFileUploadCustomEvent<FocusEvent>>,
    onBcmBlur: EventName<BcmFileUploadCustomEvent<FocusEvent>>
};

export const BcmFileUpload: StencilReactComponent<BcmFileUploadElement, BcmFileUploadEvents> = /*@__PURE__*/ createComponent<BcmFileUploadElement, BcmFileUploadEvents>({
    tagName: 'bcm-file-upload',
    elementClass: BcmFileUploadElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmFileChange: 'bcmFileChange',
        onBcmFileRemoved: 'bcmFileRemoved',
        onBcmUploadCanceled: 'bcmUploadCanceled',
        onBcmFocus: 'bcmFocus',
        onBcmBlur: 'bcmBlur'
    } as BcmFileUploadEvents,
    defineCustomElement: defineBcmFileUpload
});

export type BcmInputEvents = {
    onBcmInput: EventName<BcmInputCustomEvent<InputEvent>>,
    onBcmChange: EventName<BcmInputCustomEvent<Event>>,
    onBcmFocus: EventName<BcmInputCustomEvent<FocusEvent>>,
    onBcmBlur: EventName<BcmInputCustomEvent<FocusEvent>>,
    onBcmKeyDown: EventName<BcmInputCustomEvent<KeyboardEvent>>,
    onBcmKeyUp: EventName<BcmInputCustomEvent<KeyboardEvent>>
};

export const BcmInput: StencilReactComponent<BcmInputElement, BcmInputEvents> = /*@__PURE__*/ createComponent<BcmInputElement, BcmInputEvents>({
    tagName: 'bcm-input',
    elementClass: BcmInputElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmInput: 'bcmInput',
        onBcmChange: 'bcmChange',
        onBcmFocus: 'bcmFocus',
        onBcmBlur: 'bcmBlur',
        onBcmKeyDown: 'bcmKeyDown',
        onBcmKeyUp: 'bcmKeyUp'
    } as BcmInputEvents,
    defineCustomElement: defineBcmInput
});

export type BcmLinkedEvents = {
    onBcmBeforeShow: EventName<BcmLinkedCustomEvent<void>>,
    onBcmShow: EventName<BcmLinkedCustomEvent<void>>,
    onBcmBeforeHide: EventName<BcmLinkedCustomEvent<void>>,
    onBcmHide: EventName<BcmLinkedCustomEvent<void>>,
    onBcmShown: EventName<BcmLinkedCustomEvent<void>>,
    onBcmHidden: EventName<BcmLinkedCustomEvent<void>>
};

export const BcmLinked: StencilReactComponent<BcmLinkedElement, BcmLinkedEvents> = /*@__PURE__*/ createComponent<BcmLinkedElement, BcmLinkedEvents>({
    tagName: 'bcm-linked',
    elementClass: BcmLinkedElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmBeforeShow: 'bcmBeforeShow',
        onBcmShow: 'bcmShow',
        onBcmBeforeHide: 'bcmBeforeHide',
        onBcmHide: 'bcmHide',
        onBcmShown: 'bcmShown',
        onBcmHidden: 'bcmHidden'
    } as BcmLinkedEvents,
    defineCustomElement: defineBcmLinked
});

export type BcmModalEvents = {
    onBcmOpen: EventName<BcmModalCustomEvent<void>>,
    onBcmClose: EventName<BcmModalCustomEvent<void>>,
    onBcmBeforeOpen: EventName<BcmModalCustomEvent<void>>,
    onBcmBeforeClose: EventName<BcmModalCustomEvent<void>>
};

export const BcmModal: StencilReactComponent<BcmModalElement, BcmModalEvents> = /*@__PURE__*/ createComponent<BcmModalElement, BcmModalEvents>({
    tagName: 'bcm-modal',
    elementClass: BcmModalElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmOpen: 'bcmOpen',
        onBcmClose: 'bcmClose',
        onBcmBeforeOpen: 'bcmBeforeOpen',
        onBcmBeforeClose: 'bcmBeforeClose'
    } as BcmModalEvents,
    defineCustomElement: defineBcmModal
});

export type BcmPopConfirmEvents = {
    onBcmBeforeOpen: EventName<BcmPopConfirmCustomEvent<void>>,
    onBcmOpen: EventName<BcmPopConfirmCustomEvent<void>>,
    onBcmBeforeClose: EventName<BcmPopConfirmCustomEvent<void>>,
    onBcmClose: EventName<BcmPopConfirmCustomEvent<void>>,
    onBcmConfirm: EventName<BcmPopConfirmCustomEvent<void>>,
    onBcmCancel: EventName<BcmPopConfirmCustomEvent<void>>
};

export const BcmPopConfirm: StencilReactComponent<BcmPopConfirmElement, BcmPopConfirmEvents> = /*@__PURE__*/ createComponent<BcmPopConfirmElement, BcmPopConfirmEvents>({
    tagName: 'bcm-pop-confirm',
    elementClass: BcmPopConfirmElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmBeforeOpen: 'bcmBeforeOpen',
        onBcmOpen: 'bcmOpen',
        onBcmBeforeClose: 'bcmBeforeClose',
        onBcmClose: 'bcmClose',
        onBcmConfirm: 'bcmConfirm',
        onBcmCancel: 'bcmCancel'
    } as BcmPopConfirmEvents,
    defineCustomElement: defineBcmPopConfirm
});

export type BcmPopoverEvents = {
    onBcmBeforeOpen: EventName<BcmPopoverCustomEvent<void>>,
    onBcmOpen: EventName<BcmPopoverCustomEvent<void>>,
    onBcmBeforeClose: EventName<BcmPopoverCustomEvent<void>>,
    onBcmClose: EventName<BcmPopoverCustomEvent<void>>
};

export const BcmPopover: StencilReactComponent<BcmPopoverElement, BcmPopoverEvents> = /*@__PURE__*/ createComponent<BcmPopoverElement, BcmPopoverEvents>({
    tagName: 'bcm-popover',
    elementClass: BcmPopoverElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmBeforeOpen: 'bcmBeforeOpen',
        onBcmOpen: 'bcmOpen',
        onBcmBeforeClose: 'bcmBeforeClose',
        onBcmClose: 'bcmClose'
    } as BcmPopoverEvents,
    defineCustomElement: defineBcmPopover
});

export type BcmRadioEvents = {
    onBcmRadioChange: EventName<BcmRadioCustomEvent<void>>,
    onBcmBlur: EventName<BcmRadioCustomEvent<FocusEvent>>,
    onBcmFocus: EventName<BcmRadioCustomEvent<FocusEvent>>
};

export const BcmRadio: StencilReactComponent<BcmRadioElement, BcmRadioEvents> = /*@__PURE__*/ createComponent<BcmRadioElement, BcmRadioEvents>({
    tagName: 'bcm-radio',
    elementClass: BcmRadioElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmRadioChange: 'bcmRadioChange',
        onBcmBlur: 'bcmBlur',
        onBcmFocus: 'bcmFocus'
    } as BcmRadioEvents,
    defineCustomElement: defineBcmRadio
});

export type BcmRadioGroupEvents = { onBcmRadioGroupChange: EventName<BcmRadioGroupCustomEvent<any>> };

export const BcmRadioGroup: StencilReactComponent<BcmRadioGroupElement, BcmRadioGroupEvents> = /*@__PURE__*/ createComponent<BcmRadioGroupElement, BcmRadioGroupEvents>({
    tagName: 'bcm-radio-group',
    elementClass: BcmRadioGroupElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmRadioGroupChange: 'bcmRadioGroupChange' } as BcmRadioGroupEvents,
    defineCustomElement: defineBcmRadioGroup
});

export type BcmSegmentEvents = { onBcmSegmentClick: EventName<BcmSegmentCustomEvent<string>> };

export const BcmSegment: StencilReactComponent<BcmSegmentElement, BcmSegmentEvents> = /*@__PURE__*/ createComponent<BcmSegmentElement, BcmSegmentEvents>({
    tagName: 'bcm-segment',
    elementClass: BcmSegmentElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmSegmentClick: 'bcmSegmentClick' } as BcmSegmentEvents,
    defineCustomElement: defineBcmSegment
});

export type BcmSegmentedPickerEvents = { onBcmSegmentChange: EventName<BcmSegmentedPickerCustomEvent<{ value: string; previousValue: string }>> };

export const BcmSegmentedPicker: StencilReactComponent<BcmSegmentedPickerElement, BcmSegmentedPickerEvents> = /*@__PURE__*/ createComponent<BcmSegmentedPickerElement, BcmSegmentedPickerEvents>({
    tagName: 'bcm-segmented-picker',
    elementClass: BcmSegmentedPickerElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmSegmentChange: 'bcmSegmentChange' } as BcmSegmentedPickerEvents,
    defineCustomElement: defineBcmSegmentedPicker
});

export type BcmShortcutEvents = NonNullable<unknown>;

export const BcmShortcut: StencilReactComponent<BcmShortcutElement, BcmShortcutEvents> = /*@__PURE__*/ createComponent<BcmShortcutElement, BcmShortcutEvents>({
    tagName: 'bcm-shortcut',
    elementClass: BcmShortcutElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmShortcutEvents,
    defineCustomElement: defineBcmShortcut
});

export type BcmSwitchEvents = { onBcmSwitchChange: EventName<BcmSwitchCustomEvent<boolean>> };

export const BcmSwitch: StencilReactComponent<BcmSwitchElement, BcmSwitchEvents> = /*@__PURE__*/ createComponent<BcmSwitchElement, BcmSwitchEvents>({
    tagName: 'bcm-switch',
    elementClass: BcmSwitchElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmSwitchChange: 'bcmSwitchChange' } as BcmSwitchEvents,
    defineCustomElement: defineBcmSwitch
});

export type BcmTabEvents = { onBcmTabClick: EventName<BcmTabCustomEvent<string>> };

export const BcmTab: StencilReactComponent<BcmTabElement, BcmTabEvents> = /*@__PURE__*/ createComponent<BcmTabElement, BcmTabEvents>({
    tagName: 'bcm-tab',
    elementClass: BcmTabElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmTabClick: 'bcmTabClick' } as BcmTabEvents,
    defineCustomElement: defineBcmTab
});

export type BcmTabsEvents = {
    onBcmTabChange: EventName<BcmTabsCustomEvent<{
        value: string;
        previousValue: string;
    }>>
};

export const BcmTabs: StencilReactComponent<BcmTabsElement, BcmTabsEvents> = /*@__PURE__*/ createComponent<BcmTabsElement, BcmTabsEvents>({
    tagName: 'bcm-tabs',
    elementClass: BcmTabsElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: { onBcmTabChange: 'bcmTabChange' } as BcmTabsEvents,
    defineCustomElement: defineBcmTabs
});

export type BcmTextEvents = NonNullable<unknown>;

export const BcmText: StencilReactComponent<BcmTextElement, BcmTextEvents> = /*@__PURE__*/ createComponent<BcmTextElement, BcmTextEvents>({
    tagName: 'bcm-text',
    elementClass: BcmTextElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmTextEvents,
    defineCustomElement: defineBcmText
});

export type BcmTextareaEvents = {
    onBcmInput: EventName<BcmTextareaCustomEvent<InputEvent>>,
    onBcmChange: EventName<BcmTextareaCustomEvent<Event>>,
    onBcmFocus: EventName<BcmTextareaCustomEvent<FocusEvent>>,
    onBcmBlur: EventName<BcmTextareaCustomEvent<FocusEvent>>,
    onBcmKeyDown: EventName<BcmTextareaCustomEvent<KeyboardEvent>>,
    onBcmKeyUp: EventName<BcmTextareaCustomEvent<KeyboardEvent>>
};

export const BcmTextarea: StencilReactComponent<BcmTextareaElement, BcmTextareaEvents> = /*@__PURE__*/ createComponent<BcmTextareaElement, BcmTextareaEvents>({
    tagName: 'bcm-textarea',
    elementClass: BcmTextareaElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {
        onBcmInput: 'bcmInput',
        onBcmChange: 'bcmChange',
        onBcmFocus: 'bcmFocus',
        onBcmBlur: 'bcmBlur',
        onBcmKeyDown: 'bcmKeyDown',
        onBcmKeyUp: 'bcmKeyUp'
    } as BcmTextareaEvents,
    defineCustomElement: defineBcmTextarea
});

export type BcmTooltipEvents = NonNullable<unknown>;

export const BcmTooltip: StencilReactComponent<BcmTooltipElement, BcmTooltipEvents> = /*@__PURE__*/ createComponent<BcmTooltipElement, BcmTooltipEvents>({
    tagName: 'bcm-tooltip',
    elementClass: BcmTooltipElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BcmTooltipEvents,
    defineCustomElement: defineBcmTooltip
});