components.ts

"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 AdditionalParticipant,
  type BookedEventInfo,
  type CONFIGURATION_EVENT_TYPE,
  type Configuration,
  type CreateGroupEventFormState,
  type DropdownOption,
  type GroupConfiguration,
  type GroupEvent,
  type GroupEventAPIData,
  type ImportGroupEventDetails,
  type InputDropdownCustomEvent,
  type InputImageUrlCustomEvent,
  type Notification,
  type NylasAdditionalParticipantsCustomEvent,
  type NylasBookedEventCardCustomEvent,
  type NylasBookingCalendarPickerCustomEvent,
  type NylasBookingConfirmationRedirectCustomEvent,
  type NylasBookingConfirmationTypeCustomEvent,
  type NylasBookingFormCustomEvent,
  type NylasBufferTimeCustomEvent,
  type NylasCalendarPickerCustomEvent,
  type NylasCancelBookingFormCustomEvent,
  type NylasCancelledEventCardCustomEvent,
  type NylasConfirmationEmailCustomEvent,
  type NylasConfirmedEventCardCustomEvent,
  type NylasCustomEventSlugCustomEvent,
  type NylasCustomizeBookingSettingsCustomEvent,
  type NylasDatePickerCustomEvent,
  type NylasDisableEmailsCustomEvent,
  type NylasEditorTabsCustomEvent,
  type NylasEditorTabsGroupCustomEvent,
  type NylasEventCalendarCustomEvent,
  type NylasEventCapacityCustomEvent,
  type NylasListConfigurationsCustomEvent,
  type NylasNotetakerConfigCustomEvent,
  type NylasOrganizerConfirmationCardCustomEvent,
  type NylasPageNameCustomEvent,
  type NylasPageStylingCustomEvent,
  type NylasReminderEmailsCustomEvent,
  type NylasSchedulerBookingDataWithFlatFields,
  type NylasSchedulerEditorCustomEvent,
  type NylasSchedulerErrorResponse,
  type NylasSchedulerResponse,
  type NylasSchedulingCustomEvent,
  type NylasSchedulingMethodCustomEvent,
  type NylasSelectEventTypeCustomEvent,
  type NylasTimeslotPickerCustomEvent,
  type RecurrenceDeleteOption,
  type RecurrenceUpdateOption,
  type SchedulerEventDetail,
  type SchedulerGroupEventDetail,
  type SelectDropdownCustomEvent,
  type Timeslot,
  type UISettingsResponse,
} from "@nylas/web-elements";
import {
  AddCircleIcon as AddCircleIconElement,
  defineCustomElement as defineAddCircleIcon,
} from "@nylas/web-elements/dist/components/add-circle-icon.js";
import {
  ArchiveIcon as ArchiveIconElement,
  defineCustomElement as defineArchiveIcon,
} from "@nylas/web-elements/dist/components/archive-icon.js";
import {
  ArrowIcon as ArrowIconElement,
  defineCustomElement as defineArrowIcon,
} from "@nylas/web-elements/dist/components/arrow-icon.js";
import {
  BoldIcon as BoldIconElement,
  defineCustomElement as defineBoldIcon,
} from "@nylas/web-elements/dist/components/bold-icon.js";
import {
  ButtonComponent as ButtonComponentElement,
  defineCustomElement as defineButtonComponent,
} from "@nylas/web-elements/dist/components/button-component.js";
import {
  CalendarAgendaFillIcon as CalendarAgendaFillIconElement,
  defineCustomElement as defineCalendarAgendaFillIcon,
} from "@nylas/web-elements/dist/components/calendar-agenda-fill-icon.js";
import {
  CalendarAgendaIcon as CalendarAgendaIconElement,
  defineCustomElement as defineCalendarAgendaIcon,
} from "@nylas/web-elements/dist/components/calendar-agenda-icon.js";
import {
  CalendarCancelIcon as CalendarCancelIconElement,
  defineCustomElement as defineCalendarCancelIcon,
} from "@nylas/web-elements/dist/components/calendar-cancel-icon.js";
import {
  CalendarCheckIcon as CalendarCheckIconElement,
  defineCustomElement as defineCalendarCheckIcon,
} from "@nylas/web-elements/dist/components/calendar-check-icon.js";
import {
  CalendarIcon as CalendarIconElement,
  defineCustomElement as defineCalendarIcon,
} from "@nylas/web-elements/dist/components/calendar-icon.js";
import {
  CalendarInfoIcon as CalendarInfoIconElement,
  defineCustomElement as defineCalendarInfoIcon,
} from "@nylas/web-elements/dist/components/calendar-info-icon.js";
import {
  CalendarPatternsIcon as CalendarPatternsIconElement,
  defineCustomElement as defineCalendarPatternsIcon,
} from "@nylas/web-elements/dist/components/calendar-patterns-icon.js";
import {
  CheckboxComponent as CheckboxComponentElement,
  defineCustomElement as defineCheckboxComponent,
} from "@nylas/web-elements/dist/components/checkbox-component.js";
import {
  CheckboxGroup as CheckboxGroupElement,
  defineCustomElement as defineCheckboxGroup,
} from "@nylas/web-elements/dist/components/checkbox-group.js";
import {
  CheckmarkCircleIcon as CheckmarkCircleIconElement,
  defineCustomElement as defineCheckmarkCircleIcon,
} from "@nylas/web-elements/dist/components/checkmark-circle-icon.js";
import {
  CheckmarkIcon as CheckmarkIconElement,
  defineCustomElement as defineCheckmarkIcon,
} from "@nylas/web-elements/dist/components/checkmark-icon.js";
import {
  ChevronIcon as ChevronIconElement,
  defineCustomElement as defineChevronIcon,
} from "@nylas/web-elements/dist/components/chevron-icon.js";
import {
  ClockIcon as ClockIconElement,
  defineCustomElement as defineClockIcon,
} from "@nylas/web-elements/dist/components/clock-icon.js";
import {
  CloseIcon as CloseIconElement,
  defineCustomElement as defineCloseIcon,
} from "@nylas/web-elements/dist/components/close-icon.js";
import {
  CopyIcon as CopyIconElement,
  defineCustomElement as defineCopyIcon,
} from "@nylas/web-elements/dist/components/copy-icon.js";
import {
  DeleteIcon as DeleteIconElement,
  defineCustomElement as defineDeleteIcon,
} from "@nylas/web-elements/dist/components/delete-icon.js";
import {
  DocumentRefreshIcon as DocumentRefreshIconElement,
  defineCustomElement as defineDocumentRefreshIcon,
} from "@nylas/web-elements/dist/components/document-refresh-icon.js";
import {
  DragableIcon as DragableIconElement,
  defineCustomElement as defineDragableIcon,
} from "@nylas/web-elements/dist/components/dragable-icon.js";
import {
  EditIcon as EditIconElement,
  defineCustomElement as defineEditIcon,
} from "@nylas/web-elements/dist/components/edit-icon.js";
import {
  EnvelopeFillIcon as EnvelopeFillIconElement,
  defineCustomElement as defineEnvelopeFillIcon,
} from "@nylas/web-elements/dist/components/envelope-fill-icon.js";
import {
  EnvelopeIcon as EnvelopeIconElement,
  defineCustomElement as defineEnvelopeIcon,
} from "@nylas/web-elements/dist/components/envelope-icon.js";
import {
  EyeIcon as EyeIconElement,
  defineCustomElement as defineEyeIcon,
} from "@nylas/web-elements/dist/components/eye-icon.js";
import {
  FeedbackIcon as FeedbackIconElement,
  defineCustomElement as defineFeedbackIcon,
} from "@nylas/web-elements/dist/components/feedback-icon.js";
import {
  FlowIcon as FlowIconElement,
  defineCustomElement as defineFlowIcon,
} from "@nylas/web-elements/dist/components/flow-icon.js";
import {
  FolderIcon as FolderIconElement,
  defineCustomElement as defineFolderIcon,
} from "@nylas/web-elements/dist/components/folder-icon.js";
import {
  ForwardIcon as ForwardIconElement,
  defineCustomElement as defineForwardIcon,
} from "@nylas/web-elements/dist/components/forward-icon.js";
import {
  GlobeIcon as GlobeIconElement,
  defineCustomElement as defineGlobeIcon,
} from "@nylas/web-elements/dist/components/globe-icon.js";
import {
  GoogleLogoIcon as GoogleLogoIconElement,
  defineCustomElement as defineGoogleLogoIcon,
} from "@nylas/web-elements/dist/components/google-logo-icon.js";
import {
  GoogleMeetIcon as GoogleMeetIconElement,
  defineCustomElement as defineGoogleMeetIcon,
} from "@nylas/web-elements/dist/components/google-meet-icon.js";
import {
  InboxIcon as InboxIconElement,
  defineCustomElement as defineInboxIcon,
} from "@nylas/web-elements/dist/components/inbox-icon.js";
import {
  InfoIcon as InfoIconElement,
  defineCustomElement as defineInfoIcon,
} from "@nylas/web-elements/dist/components/info-icon.js";
import {
  InputColorPicker as InputColorPickerElement,
  defineCustomElement as defineInputColorPicker,
} from "@nylas/web-elements/dist/components/input-color-picker.js";
import {
  InputComponent as InputComponentElement,
  defineCustomElement as defineInputComponent,
} from "@nylas/web-elements/dist/components/input-component.js";
import {
  InputDropdown as InputDropdownElement,
  defineCustomElement as defineInputDropdown,
} from "@nylas/web-elements/dist/components/input-dropdown.js";
import {
  InputImageUrl as InputImageUrlElement,
  defineCustomElement as defineInputImageUrl,
} from "@nylas/web-elements/dist/components/input-image-url.js";
import {
  ItalicIcon as ItalicIconElement,
  defineCustomElement as defineItalicIcon,
} from "@nylas/web-elements/dist/components/italic-icon.js";
import {
  LoadingIcon as LoadingIconElement,
  defineCustomElement as defineLoadingIcon,
} from "@nylas/web-elements/dist/components/loading-icon.js";
import {
  LocationIcon as LocationIconElement,
  defineCustomElement as defineLocationIcon,
} from "@nylas/web-elements/dist/components/location-icon.js";
import {
  LocationOffIcon as LocationOffIconElement,
  defineCustomElement as defineLocationOffIcon,
} from "@nylas/web-elements/dist/components/location-off-icon.js";
import {
  MicrosoftLogoIcon as MicrosoftLogoIconElement,
  defineCustomElement as defineMicrosoftLogoIcon,
} from "@nylas/web-elements/dist/components/microsoft-logo-icon.js";
import {
  MicrosoftTeamsIcon as MicrosoftTeamsIconElement,
  defineCustomElement as defineMicrosoftTeamsIcon,
} from "@nylas/web-elements/dist/components/microsoft-teams-icon.js";
import {
  MultiSelectDropdown as MultiSelectDropdownElement,
  defineCustomElement as defineMultiSelectDropdown,
} from "@nylas/web-elements/dist/components/multi-select-dropdown.js";
import {
  NylasAdditionalParticipants as NylasAdditionalParticipantsElement,
  defineCustomElement as defineNylasAdditionalParticipants,
} from "@nylas/web-elements/dist/components/nylas-additional-participants.js";
import {
  NylasAvailabilityPicker as NylasAvailabilityPickerElement,
  defineCustomElement as defineNylasAvailabilityPicker,
} from "@nylas/web-elements/dist/components/nylas-availability-picker.js";
import {
  NylasBookedEventCard as NylasBookedEventCardElement,
  defineCustomElement as defineNylasBookedEventCard,
} from "@nylas/web-elements/dist/components/nylas-booked-event-card.js";
import {
  NylasBookingCalendarPicker as NylasBookingCalendarPickerElement,
  defineCustomElement as defineNylasBookingCalendarPicker,
} from "@nylas/web-elements/dist/components/nylas-booking-calendar-picker.js";
import {
  NylasBookingConfirmationRedirect as NylasBookingConfirmationRedirectElement,
  defineCustomElement as defineNylasBookingConfirmationRedirect,
} from "@nylas/web-elements/dist/components/nylas-booking-confirmation-redirect.js";
import {
  NylasBookingConfirmationType as NylasBookingConfirmationTypeElement,
  defineCustomElement as defineNylasBookingConfirmationType,
} from "@nylas/web-elements/dist/components/nylas-booking-confirmation-type.js";
import {
  NylasBookingFormConfig as NylasBookingFormConfigElement,
  defineCustomElement as defineNylasBookingFormConfig,
} from "@nylas/web-elements/dist/components/nylas-booking-form-config.js";
import {
  NylasBookingForm as NylasBookingFormElement,
  defineCustomElement as defineNylasBookingForm,
} from "@nylas/web-elements/dist/components/nylas-booking-form.js";
import {
  NylasBufferTime as NylasBufferTimeElement,
  defineCustomElement as defineNylasBufferTime,
} from "@nylas/web-elements/dist/components/nylas-buffer-time.js";
import {
  NylasCalendarPicker as NylasCalendarPickerElement,
  defineCustomElement as defineNylasCalendarPicker,
} from "@nylas/web-elements/dist/components/nylas-calendar-picker.js";
import {
  NylasCancelBookingForm as NylasCancelBookingFormElement,
  defineCustomElement as defineNylasCancelBookingForm,
} from "@nylas/web-elements/dist/components/nylas-cancel-booking-form.js";
import {
  NylasCancellationPolicy as NylasCancellationPolicyElement,
  defineCustomElement as defineNylasCancellationPolicy,
} from "@nylas/web-elements/dist/components/nylas-cancellation-policy.js";
import {
  NylasCancelledEventCard as NylasCancelledEventCardElement,
  defineCustomElement as defineNylasCancelledEventCard,
} from "@nylas/web-elements/dist/components/nylas-cancelled-event-card.js";
import {
  NylasConfirmationEmail as NylasConfirmationEmailElement,
  defineCustomElement as defineNylasConfirmationEmail,
} from "@nylas/web-elements/dist/components/nylas-confirmation-email.js";
import {
  NylasConfirmedEventCard as NylasConfirmedEventCardElement,
  defineCustomElement as defineNylasConfirmedEventCard,
} from "@nylas/web-elements/dist/components/nylas-confirmed-event-card.js";
import {
  NylasConnectedCalendars as NylasConnectedCalendarsElement,
  defineCustomElement as defineNylasConnectedCalendars,
} from "@nylas/web-elements/dist/components/nylas-connected-calendars.js";
import {
  NylasCustomBookingFlow as NylasCustomBookingFlowElement,
  defineCustomElement as defineNylasCustomBookingFlow,
} from "@nylas/web-elements/dist/components/nylas-custom-booking-flow.js";
import {
  NylasCustomEventSlug as NylasCustomEventSlugElement,
  defineCustomElement as defineNylasCustomEventSlug,
} from "@nylas/web-elements/dist/components/nylas-custom-event-slug.js";
import {
  NylasCustomizeBookingSettings as NylasCustomizeBookingSettingsElement,
  defineCustomElement as defineNylasCustomizeBookingSettings,
} from "@nylas/web-elements/dist/components/nylas-customize-booking-settings.js";
import {
  NylasDateComponent as NylasDateComponentElement,
  defineCustomElement as defineNylasDateComponent,
} from "@nylas/web-elements/dist/components/nylas-date-component.js";
import {
  NylasDatePicker as NylasDatePickerElement,
  defineCustomElement as defineNylasDatePicker,
} from "@nylas/web-elements/dist/components/nylas-date-picker.js";
import {
  NylasDisableEmails as NylasDisableEmailsElement,
  defineCustomElement as defineNylasDisableEmails,
} from "@nylas/web-elements/dist/components/nylas-disable-emails.js";
import {
  NylasEditorTabsGroup as NylasEditorTabsGroupElement,
  defineCustomElement as defineNylasEditorTabsGroup,
} from "@nylas/web-elements/dist/components/nylas-editor-tabs-group.js";
import {
  NylasEditorTabs as NylasEditorTabsElement,
  defineCustomElement as defineNylasEditorTabs,
} from "@nylas/web-elements/dist/components/nylas-editor-tabs.js";
import {
  NylasEventCalendar as NylasEventCalendarElement,
  defineCustomElement as defineNylasEventCalendar,
} from "@nylas/web-elements/dist/components/nylas-event-calendar.js";
import {
  NylasEventCapacity as NylasEventCapacityElement,
  defineCustomElement as defineNylasEventCapacity,
} from "@nylas/web-elements/dist/components/nylas-event-capacity.js";
import {
  NylasEventDescription as NylasEventDescriptionElement,
  defineCustomElement as defineNylasEventDescription,
} from "@nylas/web-elements/dist/components/nylas-event-description.js";
import {
  NylasEventDuration as NylasEventDurationElement,
  defineCustomElement as defineNylasEventDuration,
} from "@nylas/web-elements/dist/components/nylas-event-duration.js";
import {
  NylasEventInfo as NylasEventInfoElement,
  defineCustomElement as defineNylasEventInfo,
} from "@nylas/web-elements/dist/components/nylas-event-info.js";
import {
  NylasEventLimits as NylasEventLimitsElement,
  defineCustomElement as defineNylasEventLimits,
} from "@nylas/web-elements/dist/components/nylas-event-limits.js";
import {
  NylasEventLocation as NylasEventLocationElement,
  defineCustomElement as defineNylasEventLocation,
} from "@nylas/web-elements/dist/components/nylas-event-location.js";
import {
  NylasEventTimeslot as NylasEventTimeslotElement,
  defineCustomElement as defineNylasEventTimeslot,
} from "@nylas/web-elements/dist/components/nylas-event-timeslot.js";
import {
  NylasEventTitle as NylasEventTitleElement,
  defineCustomElement as defineNylasEventTitle,
} from "@nylas/web-elements/dist/components/nylas-event-title.js";
import {
  NylasFeedbackForm as NylasFeedbackFormElement,
  defineCustomElement as defineNylasFeedbackForm,
} from "@nylas/web-elements/dist/components/nylas-feedback-form.js";
import {
  NylasFormCard as NylasFormCardElement,
  defineCustomElement as defineNylasFormCard,
} from "@nylas/web-elements/dist/components/nylas-form-card.js";
import {
  NylasLimitFutureBookings as NylasLimitFutureBookingsElement,
  defineCustomElement as defineNylasLimitFutureBookings,
} from "@nylas/web-elements/dist/components/nylas-limit-future-bookings.js";
import {
  NylasListConfigurations as NylasListConfigurationsElement,
  defineCustomElement as defineNylasListConfigurations,
} from "@nylas/web-elements/dist/components/nylas-list-configurations.js";
import {
  NylasLocaleSwitch as NylasLocaleSwitchElement,
  defineCustomElement as defineNylasLocaleSwitch,
} from "@nylas/web-elements/dist/components/nylas-locale-switch.js";
import {
  NylasLogo as NylasLogoElement,
  defineCustomElement as defineNylasLogo,
} from "@nylas/web-elements/dist/components/nylas-logo.js";
import {
  NylasMinBookingNotice as NylasMinBookingNoticeElement,
  defineCustomElement as defineNylasMinBookingNotice,
} from "@nylas/web-elements/dist/components/nylas-min-booking-notice.js";
import {
  NylasMinCancellationNotice as NylasMinCancellationNoticeElement,
  defineCustomElement as defineNylasMinCancellationNotice,
} from "@nylas/web-elements/dist/components/nylas-min-cancellation-notice.js";
import {
  NylasNotetakerConfig as NylasNotetakerConfigElement,
  defineCustomElement as defineNylasNotetakerConfig,
} from "@nylas/web-elements/dist/components/nylas-notetaker-config.js";
import {
  NylasNotification as NylasNotificationElement,
  defineCustomElement as defineNylasNotification,
} from "@nylas/web-elements/dist/components/nylas-notification.js";
import {
  NylasOnlySpecificTimeAvailability as NylasOnlySpecificTimeAvailabilityElement,
  defineCustomElement as defineNylasOnlySpecificTimeAvailability,
} from "@nylas/web-elements/dist/components/nylas-only-specific-time-availability.js";
import {
  NylasOrganizerConfirmationCard as NylasOrganizerConfirmationCardElement,
  defineCustomElement as defineNylasOrganizerConfirmationCard,
} from "@nylas/web-elements/dist/components/nylas-organizer-confirmation-card.js";
import {
  NylasPageName as NylasPageNameElement,
  defineCustomElement as defineNylasPageName,
} from "@nylas/web-elements/dist/components/nylas-page-name.js";
import {
  NylasPageStyling as NylasPageStylingElement,
  defineCustomElement as defineNylasPageStyling,
} from "@nylas/web-elements/dist/components/nylas-page-styling.js";
import {
  NylasParticipantBookingCalendars as NylasParticipantBookingCalendarsElement,
  defineCustomElement as defineNylasParticipantBookingCalendars,
} from "@nylas/web-elements/dist/components/nylas-participant-booking-calendars.js";
import {
  NylasParticipantsCustomAvailability as NylasParticipantsCustomAvailabilityElement,
  defineCustomElement as defineNylasParticipantsCustomAvailability,
} from "@nylas/web-elements/dist/components/nylas-participants-custom-availability.js";
import {
  NylasReminderEmails as NylasReminderEmailsElement,
  defineCustomElement as defineNylasReminderEmails,
} from "@nylas/web-elements/dist/components/nylas-reminder-emails.js";
import {
  NylasReminderTime as NylasReminderTimeElement,
  defineCustomElement as defineNylasReminderTime,
} from "@nylas/web-elements/dist/components/nylas-reminder-time.js";
import {
  NylasSchedulerEditor as NylasSchedulerEditorElement,
  defineCustomElement as defineNylasSchedulerEditor,
} from "@nylas/web-elements/dist/components/nylas-scheduler-editor.js";
import {
  NylasSchedulingMethod as NylasSchedulingMethodElement,
  defineCustomElement as defineNylasSchedulingMethod,
} from "@nylas/web-elements/dist/components/nylas-scheduling-method.js";
import {
  NylasScheduling as NylasSchedulingElement,
  defineCustomElement as defineNylasScheduling,
} from "@nylas/web-elements/dist/components/nylas-scheduling.js";
import {
  NylasSelectEventType as NylasSelectEventTypeElement,
  defineCustomElement as defineNylasSelectEventType,
} from "@nylas/web-elements/dist/components/nylas-select-event-type.js";
import {
  NylasSelectedEventCard as NylasSelectedEventCardElement,
  defineCustomElement as defineNylasSelectedEventCard,
} from "@nylas/web-elements/dist/components/nylas-selected-event-card.js";
import {
  NylasSpecificTimeAvailabilityPicker as NylasSpecificTimeAvailabilityPickerElement,
  defineCustomElement as defineNylasSpecificTimeAvailabilityPicker,
} from "@nylas/web-elements/dist/components/nylas-specific-time-availability-picker.js";
import {
  NylasTimeWindowPicker as NylasTimeWindowPickerElement,
  defineCustomElement as defineNylasTimeWindowPicker,
} from "@nylas/web-elements/dist/components/nylas-time-window-picker.js";
import {
  NylasTimeslotInterval as NylasTimeslotIntervalElement,
  defineCustomElement as defineNylasTimeslotInterval,
} from "@nylas/web-elements/dist/components/nylas-timeslot-interval.js";
import {
  NylasTimeslotPicker as NylasTimeslotPickerElement,
  defineCustomElement as defineNylasTimeslotPicker,
} from "@nylas/web-elements/dist/components/nylas-timeslot-picker.js";
import {
  PaintbrushFillIcon as PaintbrushFillIconElement,
  defineCustomElement as definePaintbrushFillIcon,
} from "@nylas/web-elements/dist/components/paintbrush-fill-icon.js";
import {
  PaintbrushIcon as PaintbrushIconElement,
  defineCustomElement as definePaintbrushIcon,
} from "@nylas/web-elements/dist/components/paintbrush-icon.js";
import {
  PeopleIcon as PeopleIconElement,
  defineCustomElement as definePeopleIcon,
} from "@nylas/web-elements/dist/components/people-icon.js";
import {
  PersonClipboardIcon as PersonClipboardIconElement,
  defineCustomElement as definePersonClipboardIcon,
} from "@nylas/web-elements/dist/components/person-clipboard-icon.js";
import {
  PersonIcon as PersonIconElement,
  defineCustomElement as definePersonIcon,
} from "@nylas/web-elements/dist/components/person-icon.js";
import {
  PlayIcon as PlayIconElement,
  defineCustomElement as definePlayIcon,
} from "@nylas/web-elements/dist/components/play-icon.js";
import {
  PlusIcon as PlusIconElement,
  defineCustomElement as definePlusIcon,
} from "@nylas/web-elements/dist/components/plus-icon.js";
import {
  RadioButtonGroup as RadioButtonGroupElement,
  defineCustomElement as defineRadioButtonGroup,
} from "@nylas/web-elements/dist/components/radio-button-group.js";
import {
  RefreshIcon as RefreshIconElement,
  defineCustomElement as defineRefreshIcon,
} from "@nylas/web-elements/dist/components/refresh-icon.js";
import {
  ReplyAllIcon as ReplyAllIconElement,
  defineCustomElement as defineReplyAllIcon,
} from "@nylas/web-elements/dist/components/reply-all-icon.js";
import {
  ReplyIcon as ReplyIconElement,
  defineCustomElement as defineReplyIcon,
} from "@nylas/web-elements/dist/components/reply-icon.js";
import {
  SearchIcon as SearchIconElement,
  defineCustomElement as defineSearchIcon,
} from "@nylas/web-elements/dist/components/search-icon.js";
import {
  SelectDropdown as SelectDropdownElement,
  defineCustomElement as defineSelectDropdown,
} from "@nylas/web-elements/dist/components/select-dropdown.js";
import {
  SentIcon as SentIconElement,
  defineCustomElement as defineSentIcon,
} from "@nylas/web-elements/dist/components/sent-icon.js";
import {
  SpamIcon as SpamIconElement,
  defineCustomElement as defineSpamIcon,
} from "@nylas/web-elements/dist/components/spam-icon.js";
import {
  StarIcon as StarIconElement,
  defineCustomElement as defineStarIcon,
} from "@nylas/web-elements/dist/components/star-icon.js";
import {
  StopIcon as StopIconElement,
  defineCustomElement as defineStopIcon,
} from "@nylas/web-elements/dist/components/stop-icon.js";
import {
  TextareaComponent as TextareaComponentElement,
  defineCustomElement as defineTextareaComponent,
} from "@nylas/web-elements/dist/components/textarea-component.js";
import {
  TimePeriodSelector as TimePeriodSelectorElement,
  defineCustomElement as defineTimePeriodSelector,
} from "@nylas/web-elements/dist/components/time-period-selector.js";
import {
  ToggleSwitch as ToggleSwitchElement,
  defineCustomElement as defineToggleSwitch,
} from "@nylas/web-elements/dist/components/toggle-switch.js";
import {
  TooltipComponent as TooltipComponentElement,
  defineCustomElement as defineTooltipComponent,
} from "@nylas/web-elements/dist/components/tooltip-component.js";
import {
  TranslateIcon as TranslateIconElement,
  defineCustomElement as defineTranslateIcon,
} from "@nylas/web-elements/dist/components/translate-icon.js";
import {
  TrashFillIcon as TrashFillIconElement,
  defineCustomElement as defineTrashFillIcon,
} from "@nylas/web-elements/dist/components/trash-fill-icon.js";
import {
  TrashIcon as TrashIconElement,
  defineCustomElement as defineTrashIcon,
} from "@nylas/web-elements/dist/components/trash-icon.js";
import {
  UnderlineIcon as UnderlineIconElement,
  defineCustomElement as defineUnderlineIcon,
} from "@nylas/web-elements/dist/components/underline-icon.js";
import {
  WarningIcon as WarningIconElement,
  defineCustomElement as defineWarningIcon,
} from "@nylas/web-elements/dist/components/warning-icon.js";
import {
  ZoomIcon as ZoomIconElement,
  defineCustomElement as defineZoomIcon,
} from "@nylas/web-elements/dist/components/zoom-icon.js";
import type {
  EventName,
  StencilReactComponent,
} from "@stencil/react-output-target/runtime";
import { createComponent } from "@stencil/react-output-target/runtime";
import React from "react";

export type AddCircleIconEvents = NonNullable<unknown>;

export const AddCircleIcon: StencilReactComponent<
  AddCircleIconElement,
  AddCircleIconEvents
> = /*@__PURE__*/ createComponent<AddCircleIconElement, AddCircleIconEvents>({
  tagName: "add-circle-icon",
  elementClass: AddCircleIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as AddCircleIconEvents,
  defineCustomElement: defineAddCircleIcon,
});

export type ArchiveIconEvents = NonNullable<unknown>;

export const ArchiveIcon: StencilReactComponent<
  ArchiveIconElement,
  ArchiveIconEvents
> = /*@__PURE__*/ createComponent<ArchiveIconElement, ArchiveIconEvents>({
  tagName: "archive-icon",
  elementClass: ArchiveIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ArchiveIconEvents,
  defineCustomElement: defineArchiveIcon,
});

export type ArrowIconEvents = NonNullable<unknown>;

export const ArrowIcon: StencilReactComponent<
  ArrowIconElement,
  ArrowIconEvents
> = /*@__PURE__*/ createComponent<ArrowIconElement, ArrowIconEvents>({
  tagName: "arrow-icon",
  elementClass: ArrowIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ArrowIconEvents,
  defineCustomElement: defineArrowIcon,
});

export type BoldIconEvents = NonNullable<unknown>;

export const BoldIcon: StencilReactComponent<BoldIconElement, BoldIconEvents> =
  /*@__PURE__*/ createComponent<BoldIconElement, BoldIconEvents>({
    tagName: "bold-icon",
    elementClass: BoldIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as BoldIconEvents,
    defineCustomElement: defineBoldIcon,
  });

export type ButtonComponentEvents = NonNullable<unknown>;

export const ButtonComponent: StencilReactComponent<
  ButtonComponentElement,
  ButtonComponentEvents
> = /*@__PURE__*/ createComponent<
  ButtonComponentElement,
  ButtonComponentEvents
>({
  tagName: "button-component",
  elementClass: ButtonComponentElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ButtonComponentEvents,
  defineCustomElement: defineButtonComponent,
});

export type CalendarAgendaFillIconEvents = NonNullable<unknown>;

export const CalendarAgendaFillIcon: StencilReactComponent<
  CalendarAgendaFillIconElement,
  CalendarAgendaFillIconEvents
> = /*@__PURE__*/ createComponent<
  CalendarAgendaFillIconElement,
  CalendarAgendaFillIconEvents
>({
  tagName: "calendar-agenda-fill-icon",
  elementClass: CalendarAgendaFillIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CalendarAgendaFillIconEvents,
  defineCustomElement: defineCalendarAgendaFillIcon,
});

export type CalendarAgendaIconEvents = NonNullable<unknown>;

export const CalendarAgendaIcon: StencilReactComponent<
  CalendarAgendaIconElement,
  CalendarAgendaIconEvents
> = /*@__PURE__*/ createComponent<
  CalendarAgendaIconElement,
  CalendarAgendaIconEvents
>({
  tagName: "calendar-agenda-icon",
  elementClass: CalendarAgendaIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CalendarAgendaIconEvents,
  defineCustomElement: defineCalendarAgendaIcon,
});

export type CalendarCancelIconEvents = NonNullable<unknown>;

export const CalendarCancelIcon: StencilReactComponent<
  CalendarCancelIconElement,
  CalendarCancelIconEvents
> = /*@__PURE__*/ createComponent<
  CalendarCancelIconElement,
  CalendarCancelIconEvents
>({
  tagName: "calendar-cancel-icon",
  elementClass: CalendarCancelIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CalendarCancelIconEvents,
  defineCustomElement: defineCalendarCancelIcon,
});

export type CalendarCheckIconEvents = NonNullable<unknown>;

export const CalendarCheckIcon: StencilReactComponent<
  CalendarCheckIconElement,
  CalendarCheckIconEvents
> = /*@__PURE__*/ createComponent<
  CalendarCheckIconElement,
  CalendarCheckIconEvents
>({
  tagName: "calendar-check-icon",
  elementClass: CalendarCheckIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CalendarCheckIconEvents,
  defineCustomElement: defineCalendarCheckIcon,
});

export type CalendarIconEvents = NonNullable<unknown>;

export const CalendarIcon: StencilReactComponent<
  CalendarIconElement,
  CalendarIconEvents
> = /*@__PURE__*/ createComponent<CalendarIconElement, CalendarIconEvents>({
  tagName: "calendar-icon",
  elementClass: CalendarIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CalendarIconEvents,
  defineCustomElement: defineCalendarIcon,
});

export type CalendarInfoIconEvents = NonNullable<unknown>;

export const CalendarInfoIcon: StencilReactComponent<
  CalendarInfoIconElement,
  CalendarInfoIconEvents
> = /*@__PURE__*/ createComponent<
  CalendarInfoIconElement,
  CalendarInfoIconEvents
>({
  tagName: "calendar-info-icon",
  elementClass: CalendarInfoIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CalendarInfoIconEvents,
  defineCustomElement: defineCalendarInfoIcon,
});

export type CalendarPatternsIconEvents = NonNullable<unknown>;

export const CalendarPatternsIcon: StencilReactComponent<
  CalendarPatternsIconElement,
  CalendarPatternsIconEvents
> = /*@__PURE__*/ createComponent<
  CalendarPatternsIconElement,
  CalendarPatternsIconEvents
>({
  tagName: "calendar-patterns-icon",
  elementClass: CalendarPatternsIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CalendarPatternsIconEvents,
  defineCustomElement: defineCalendarPatternsIcon,
});

export type CheckboxComponentEvents = {
  onNylasFormCheckboxToggled: EventName<
    CustomEvent<{
      checked: boolean;
      name: string;
      label: string;
    }>
  >;
};

export const CheckboxComponent: StencilReactComponent<
  CheckboxComponentElement,
  CheckboxComponentEvents
> = /*@__PURE__*/ createComponent<
  CheckboxComponentElement,
  CheckboxComponentEvents
>({
  tagName: "checkbox-component",
  elementClass: CheckboxComponentElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormCheckboxToggled: "nylasFormCheckboxToggled",
  } as CheckboxComponentEvents,
  defineCustomElement: defineCheckboxComponent,
});

export type CheckboxGroupEvents = {
  onNylasCheckboxGroupChanged: EventName<
    CustomEvent<{
      selectedValues: string[];
      name: string;
    }>
  >;
};

export const CheckboxGroup: StencilReactComponent<
  CheckboxGroupElement,
  CheckboxGroupEvents
> = /*@__PURE__*/ createComponent<CheckboxGroupElement, CheckboxGroupEvents>({
  tagName: "checkbox-group",
  elementClass: CheckboxGroupElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasCheckboxGroupChanged: "nylasCheckboxGroupChanged",
  } as CheckboxGroupEvents,
  defineCustomElement: defineCheckboxGroup,
});

export type CheckmarkCircleIconEvents = NonNullable<unknown>;

export const CheckmarkCircleIcon: StencilReactComponent<
  CheckmarkCircleIconElement,
  CheckmarkCircleIconEvents
> = /*@__PURE__*/ createComponent<
  CheckmarkCircleIconElement,
  CheckmarkCircleIconEvents
>({
  tagName: "checkmark-circle-icon",
  elementClass: CheckmarkCircleIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CheckmarkCircleIconEvents,
  defineCustomElement: defineCheckmarkCircleIcon,
});

export type CheckmarkIconEvents = NonNullable<unknown>;

export const CheckmarkIcon: StencilReactComponent<
  CheckmarkIconElement,
  CheckmarkIconEvents
> = /*@__PURE__*/ createComponent<CheckmarkIconElement, CheckmarkIconEvents>({
  tagName: "checkmark-icon",
  elementClass: CheckmarkIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CheckmarkIconEvents,
  defineCustomElement: defineCheckmarkIcon,
});

export type ChevronIconEvents = NonNullable<unknown>;

export const ChevronIcon: StencilReactComponent<
  ChevronIconElement,
  ChevronIconEvents
> = /*@__PURE__*/ createComponent<ChevronIconElement, ChevronIconEvents>({
  tagName: "chevron-icon",
  elementClass: ChevronIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ChevronIconEvents,
  defineCustomElement: defineChevronIcon,
});

export type ClockIconEvents = NonNullable<unknown>;

export const ClockIcon: StencilReactComponent<
  ClockIconElement,
  ClockIconEvents
> = /*@__PURE__*/ createComponent<ClockIconElement, ClockIconEvents>({
  tagName: "clock-icon",
  elementClass: ClockIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ClockIconEvents,
  defineCustomElement: defineClockIcon,
});

export type CloseIconEvents = NonNullable<unknown>;

export const CloseIcon: StencilReactComponent<
  CloseIconElement,
  CloseIconEvents
> = /*@__PURE__*/ createComponent<CloseIconElement, CloseIconEvents>({
  tagName: "close-icon",
  elementClass: CloseIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as CloseIconEvents,
  defineCustomElement: defineCloseIcon,
});

export type CopyIconEvents = NonNullable<unknown>;

export const CopyIcon: StencilReactComponent<CopyIconElement, CopyIconEvents> =
  /*@__PURE__*/ createComponent<CopyIconElement, CopyIconEvents>({
    tagName: "copy-icon",
    elementClass: CopyIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as CopyIconEvents,
    defineCustomElement: defineCopyIcon,
  });

export type DeleteIconEvents = NonNullable<unknown>;

export const DeleteIcon: StencilReactComponent<
  DeleteIconElement,
  DeleteIconEvents
> = /*@__PURE__*/ createComponent<DeleteIconElement, DeleteIconEvents>({
  tagName: "delete-icon",
  elementClass: DeleteIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as DeleteIconEvents,
  defineCustomElement: defineDeleteIcon,
});

export type DocumentRefreshIconEvents = NonNullable<unknown>;

export const DocumentRefreshIcon: StencilReactComponent<
  DocumentRefreshIconElement,
  DocumentRefreshIconEvents
> = /*@__PURE__*/ createComponent<
  DocumentRefreshIconElement,
  DocumentRefreshIconEvents
>({
  tagName: "document-refresh-icon",
  elementClass: DocumentRefreshIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as DocumentRefreshIconEvents,
  defineCustomElement: defineDocumentRefreshIcon,
});

export type DragableIconEvents = NonNullable<unknown>;

export const DragableIcon: StencilReactComponent<
  DragableIconElement,
  DragableIconEvents
> = /*@__PURE__*/ createComponent<DragableIconElement, DragableIconEvents>({
  tagName: "dragable-icon",
  elementClass: DragableIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as DragableIconEvents,
  defineCustomElement: defineDragableIcon,
});

export type EditIconEvents = NonNullable<unknown>;

export const EditIcon: StencilReactComponent<EditIconElement, EditIconEvents> =
  /*@__PURE__*/ createComponent<EditIconElement, EditIconEvents>({
    tagName: "edit-icon",
    elementClass: EditIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as EditIconEvents,
    defineCustomElement: defineEditIcon,
  });

export type EnvelopeFillIconEvents = NonNullable<unknown>;

export const EnvelopeFillIcon: StencilReactComponent<
  EnvelopeFillIconElement,
  EnvelopeFillIconEvents
> = /*@__PURE__*/ createComponent<
  EnvelopeFillIconElement,
  EnvelopeFillIconEvents
>({
  tagName: "envelope-fill-icon",
  elementClass: EnvelopeFillIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as EnvelopeFillIconEvents,
  defineCustomElement: defineEnvelopeFillIcon,
});

export type EnvelopeIconEvents = NonNullable<unknown>;

export const EnvelopeIcon: StencilReactComponent<
  EnvelopeIconElement,
  EnvelopeIconEvents
> = /*@__PURE__*/ createComponent<EnvelopeIconElement, EnvelopeIconEvents>({
  tagName: "envelope-icon",
  elementClass: EnvelopeIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as EnvelopeIconEvents,
  defineCustomElement: defineEnvelopeIcon,
});

export type EyeIconEvents = NonNullable<unknown>;

export const EyeIcon: StencilReactComponent<EyeIconElement, EyeIconEvents> =
  /*@__PURE__*/ createComponent<EyeIconElement, EyeIconEvents>({
    tagName: "eye-icon",
    elementClass: EyeIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as EyeIconEvents,
    defineCustomElement: defineEyeIcon,
  });

export type FeedbackIconEvents = NonNullable<unknown>;

export const FeedbackIcon: StencilReactComponent<
  FeedbackIconElement,
  FeedbackIconEvents
> = /*@__PURE__*/ createComponent<FeedbackIconElement, FeedbackIconEvents>({
  tagName: "feedback-icon",
  elementClass: FeedbackIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as FeedbackIconEvents,
  defineCustomElement: defineFeedbackIcon,
});

export type FlowIconEvents = NonNullable<unknown>;

export const FlowIcon: StencilReactComponent<FlowIconElement, FlowIconEvents> =
  /*@__PURE__*/ createComponent<FlowIconElement, FlowIconEvents>({
    tagName: "flow-icon",
    elementClass: FlowIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as FlowIconEvents,
    defineCustomElement: defineFlowIcon,
  });

export type FolderIconEvents = NonNullable<unknown>;

export const FolderIcon: StencilReactComponent<
  FolderIconElement,
  FolderIconEvents
> = /*@__PURE__*/ createComponent<FolderIconElement, FolderIconEvents>({
  tagName: "folder-icon",
  elementClass: FolderIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as FolderIconEvents,
  defineCustomElement: defineFolderIcon,
});

export type ForwardIconEvents = NonNullable<unknown>;

export const ForwardIcon: StencilReactComponent<
  ForwardIconElement,
  ForwardIconEvents
> = /*@__PURE__*/ createComponent<ForwardIconElement, ForwardIconEvents>({
  tagName: "forward-icon",
  elementClass: ForwardIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ForwardIconEvents,
  defineCustomElement: defineForwardIcon,
});

export type GlobeIconEvents = NonNullable<unknown>;

export const GlobeIcon: StencilReactComponent<
  GlobeIconElement,
  GlobeIconEvents
> = /*@__PURE__*/ createComponent<GlobeIconElement, GlobeIconEvents>({
  tagName: "globe-icon",
  elementClass: GlobeIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as GlobeIconEvents,
  defineCustomElement: defineGlobeIcon,
});

export type GoogleLogoIconEvents = NonNullable<unknown>;

export const GoogleLogoIcon: StencilReactComponent<
  GoogleLogoIconElement,
  GoogleLogoIconEvents
> = /*@__PURE__*/ createComponent<GoogleLogoIconElement, GoogleLogoIconEvents>({
  tagName: "google-logo-icon",
  elementClass: GoogleLogoIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as GoogleLogoIconEvents,
  defineCustomElement: defineGoogleLogoIcon,
});

export type GoogleMeetIconEvents = NonNullable<unknown>;

export const GoogleMeetIcon: StencilReactComponent<
  GoogleMeetIconElement,
  GoogleMeetIconEvents
> = /*@__PURE__*/ createComponent<GoogleMeetIconElement, GoogleMeetIconEvents>({
  tagName: "google-meet-icon",
  elementClass: GoogleMeetIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as GoogleMeetIconEvents,
  defineCustomElement: defineGoogleMeetIcon,
});

export type InboxIconEvents = NonNullable<unknown>;

export const InboxIcon: StencilReactComponent<
  InboxIconElement,
  InboxIconEvents
> = /*@__PURE__*/ createComponent<InboxIconElement, InboxIconEvents>({
  tagName: "inbox-icon",
  elementClass: InboxIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as InboxIconEvents,
  defineCustomElement: defineInboxIcon,
});

export type InfoIconEvents = NonNullable<unknown>;

export const InfoIcon: StencilReactComponent<InfoIconElement, InfoIconEvents> =
  /*@__PURE__*/ createComponent<InfoIconElement, InfoIconEvents>({
    tagName: "info-icon",
    elementClass: InfoIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as InfoIconEvents,
    defineCustomElement: defineInfoIcon,
  });

export type InputColorPickerEvents = {
  onNylasFormDropdownChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
      error?: string;
      label?: string;
    }>
  >;
};

export const InputColorPicker: StencilReactComponent<
  InputColorPickerElement,
  InputColorPickerEvents
> = /*@__PURE__*/ createComponent<
  InputColorPickerElement,
  InputColorPickerEvents
>({
  tagName: "input-color-picker",
  elementClass: InputColorPickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormDropdownChanged: "nylasFormDropdownChanged",
  } as InputColorPickerEvents,
  defineCustomElement: defineInputColorPicker,
});

export type InputComponentEvents = {
  onNylasFormInputChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
      label: string;
      type: string;
      error: string;
    }>
  >;
  onNylasFormInputFocused: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
  onNylasFormInputBlurred: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const InputComponent: StencilReactComponent<
  InputComponentElement,
  InputComponentEvents
> = /*@__PURE__*/ createComponent<InputComponentElement, InputComponentEvents>({
  tagName: "input-component",
  elementClass: InputComponentElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormInputChanged: "nylasFormInputChanged",
    onNylasFormInputFocused: "nylasFormInputFocused",
    onNylasFormInputBlurred: "nylasFormInputBlurred",
  } as InputComponentEvents,
  defineCustomElement: defineInputComponent,
});

export type InputDropdownEvents = {
  onInputOptionChanged: EventName<
    InputDropdownCustomEvent<{
      value: DropdownOption["value"];
      name: string;
    }>
  >;
};

export const InputDropdown: StencilReactComponent<
  InputDropdownElement,
  InputDropdownEvents
> = /*@__PURE__*/ createComponent<InputDropdownElement, InputDropdownEvents>({
  tagName: "input-dropdown",
  elementClass: InputDropdownElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onInputOptionChanged: "inputOptionChanged" } as InputDropdownEvents,
  defineCustomElement: defineInputDropdown,
});

export type InputImageUrlEvents = {
  onNylasFormInputImageUrlInvalid: EventName<
    CustomEvent<{ value: string; name: string }>
  >;
  onValueChanged: EventName<
    InputImageUrlCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const InputImageUrl: StencilReactComponent<
  InputImageUrlElement,
  InputImageUrlEvents
> = /*@__PURE__*/ createComponent<InputImageUrlElement, InputImageUrlEvents>({
  tagName: "input-image-url",
  elementClass: InputImageUrlElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormInputImageUrlInvalid: "nylasFormInputImageUrlInvalid",
    onValueChanged: "valueChanged",
  } as InputImageUrlEvents,
  defineCustomElement: defineInputImageUrl,
});

export type ItalicIconEvents = NonNullable<unknown>;

export const ItalicIcon: StencilReactComponent<
  ItalicIconElement,
  ItalicIconEvents
> = /*@__PURE__*/ createComponent<ItalicIconElement, ItalicIconEvents>({
  tagName: "italic-icon",
  elementClass: ItalicIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ItalicIconEvents,
  defineCustomElement: defineItalicIcon,
});

export type LoadingIconEvents = NonNullable<unknown>;

export const LoadingIcon: StencilReactComponent<
  LoadingIconElement,
  LoadingIconEvents
> = /*@__PURE__*/ createComponent<LoadingIconElement, LoadingIconEvents>({
  tagName: "loading-icon",
  elementClass: LoadingIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as LoadingIconEvents,
  defineCustomElement: defineLoadingIcon,
});

export type LocationIconEvents = NonNullable<unknown>;

export const LocationIcon: StencilReactComponent<
  LocationIconElement,
  LocationIconEvents
> = /*@__PURE__*/ createComponent<LocationIconElement, LocationIconEvents>({
  tagName: "location-icon",
  elementClass: LocationIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as LocationIconEvents,
  defineCustomElement: defineLocationIcon,
});

export type LocationOffIconEvents = NonNullable<unknown>;

export const LocationOffIcon: StencilReactComponent<
  LocationOffIconElement,
  LocationOffIconEvents
> = /*@__PURE__*/ createComponent<
  LocationOffIconElement,
  LocationOffIconEvents
>({
  tagName: "location-off-icon",
  elementClass: LocationOffIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as LocationOffIconEvents,
  defineCustomElement: defineLocationOffIcon,
});

export type MicrosoftLogoIconEvents = NonNullable<unknown>;

export const MicrosoftLogoIcon: StencilReactComponent<
  MicrosoftLogoIconElement,
  MicrosoftLogoIconEvents
> = /*@__PURE__*/ createComponent<
  MicrosoftLogoIconElement,
  MicrosoftLogoIconEvents
>({
  tagName: "microsoft-logo-icon",
  elementClass: MicrosoftLogoIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as MicrosoftLogoIconEvents,
  defineCustomElement: defineMicrosoftLogoIcon,
});

export type MicrosoftTeamsIconEvents = NonNullable<unknown>;

export const MicrosoftTeamsIcon: StencilReactComponent<
  MicrosoftTeamsIconElement,
  MicrosoftTeamsIconEvents
> = /*@__PURE__*/ createComponent<
  MicrosoftTeamsIconElement,
  MicrosoftTeamsIconEvents
>({
  tagName: "microsoft-teams-icon",
  elementClass: MicrosoftTeamsIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as MicrosoftTeamsIconEvents,
  defineCustomElement: defineMicrosoftTeamsIcon,
});

export type MultiSelectDropdownEvents = {
  onSelectedOptionsChanged: EventName<
    CustomEvent<{
      value: string[];
      name: string;
    }>
  >;
};

export const MultiSelectDropdown: StencilReactComponent<
  MultiSelectDropdownElement,
  MultiSelectDropdownEvents
> = /*@__PURE__*/ createComponent<
  MultiSelectDropdownElement,
  MultiSelectDropdownEvents
>({
  tagName: "multi-select-dropdown",
  elementClass: MultiSelectDropdownElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onSelectedOptionsChanged: "selectedOptionsChanged",
  } as MultiSelectDropdownEvents,
  defineCustomElement: defineMultiSelectDropdown,
});

export type NylasAdditionalParticipantsEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
  onParticipantSearchResultSelected: EventName<
    NylasAdditionalParticipantsCustomEvent<AdditionalParticipant>
  >;
};

export const NylasAdditionalParticipants: StencilReactComponent<
  NylasAdditionalParticipantsElement,
  NylasAdditionalParticipantsEvents
> = /*@__PURE__*/ createComponent<
  NylasAdditionalParticipantsElement,
  NylasAdditionalParticipantsEvents
>({
  tagName: "nylas-additional-participants",
  elementClass: NylasAdditionalParticipantsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
    onParticipantSearchResultSelected: "participantSearchResultSelected",
  } as NylasAdditionalParticipantsEvents,
  defineCustomElement: defineNylasAdditionalParticipants,
});

export type NylasAvailabilityPickerEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasAvailabilityPicker: StencilReactComponent<
  NylasAvailabilityPickerElement,
  NylasAvailabilityPickerEvents
> = /*@__PURE__*/ createComponent<
  NylasAvailabilityPickerElement,
  NylasAvailabilityPickerEvents
>({
  tagName: "nylas-availability-picker",
  elementClass: NylasAvailabilityPickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasAvailabilityPickerEvents,
  defineCustomElement: defineNylasAvailabilityPicker,
});

export type NylasBookedEventCardEvents = {
  onCancelBookingButtonClicked: EventName<CustomEvent<{ bookingId: string }>>;
  onRescheduleButtonClicked: EventName<
    NylasBookedEventCardCustomEvent<{
      bookingId: string;
      errorHandler?: (error: NylasSchedulerErrorResponse) => void;
    }>
  >;
  onRescheduleBookedEventError: EventName<
    NylasBookedEventCardCustomEvent<NylasSchedulerErrorResponse>
  >;
  onCancelBookedEventValidationError: EventName<
    CustomEvent<{
      error: {
        title: string;
        message: string;
      };
    }>
  >;
};

export const NylasBookedEventCard: StencilReactComponent<
  NylasBookedEventCardElement,
  NylasBookedEventCardEvents
> = /*@__PURE__*/ createComponent<
  NylasBookedEventCardElement,
  NylasBookedEventCardEvents
>({
  tagName: "nylas-booked-event-card",
  elementClass: NylasBookedEventCardElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onCancelBookingButtonClicked: "cancelBookingButtonClicked",
    onRescheduleButtonClicked: "rescheduleButtonClicked",
    onRescheduleBookedEventError: "rescheduleBookedEventError",
    onCancelBookedEventValidationError: "cancelBookedEventValidationError",
  } as NylasBookedEventCardEvents,
  defineCustomElement: defineNylasBookedEventCard,
});

export type NylasBookingCalendarPickerEvents = {
  onValueChanged: EventName<
    NylasBookingCalendarPickerCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasBookingCalendarPicker: StencilReactComponent<
  NylasBookingCalendarPickerElement,
  NylasBookingCalendarPickerEvents
> = /*@__PURE__*/ createComponent<
  NylasBookingCalendarPickerElement,
  NylasBookingCalendarPickerEvents
>({
  tagName: "nylas-booking-calendar-picker",
  elementClass: NylasBookingCalendarPickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasBookingCalendarPickerEvents,
  defineCustomElement: defineNylasBookingCalendarPicker,
});

export type NylasBookingConfirmationRedirectEvents = {
  onValueChanged: EventName<
    NylasBookingConfirmationRedirectCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasBookingConfirmationRedirect: StencilReactComponent<
  NylasBookingConfirmationRedirectElement,
  NylasBookingConfirmationRedirectEvents
> = /*@__PURE__*/ createComponent<
  NylasBookingConfirmationRedirectElement,
  NylasBookingConfirmationRedirectEvents
>({
  tagName: "nylas-booking-confirmation-redirect",
  elementClass: NylasBookingConfirmationRedirectElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasBookingConfirmationRedirectEvents,
  defineCustomElement: defineNylasBookingConfirmationRedirect,
});

export type NylasBookingConfirmationTypeEvents = {
  onValueChanged: EventName<
    NylasBookingConfirmationTypeCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasBookingConfirmationType: StencilReactComponent<
  NylasBookingConfirmationTypeElement,
  NylasBookingConfirmationTypeEvents
> = /*@__PURE__*/ createComponent<
  NylasBookingConfirmationTypeElement,
  NylasBookingConfirmationTypeEvents
>({
  tagName: "nylas-booking-confirmation-type",
  elementClass: NylasBookingConfirmationTypeElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasBookingConfirmationTypeEvents,
  defineCustomElement: defineNylasBookingConfirmationType,
});

export type NylasBookingFormEvents = {
  onNameChanged: EventName<CustomEvent<string>>;
  onEmailChanged: EventName<CustomEvent<string>>;
  onBackButtonClicked: EventName<CustomEvent<boolean>>;
  onDetailsConfirmed: EventName<
    NylasBookingFormCustomEvent<NylasSchedulerBookingDataWithFlatFields>
  >;
  onBookingFormError: EventName<
    NylasBookingFormCustomEvent<Partial<Notification>>
  >;
  onBookingFormSubmitted: EventName<CustomEvent<void>>;
};

export const NylasBookingForm: StencilReactComponent<
  NylasBookingFormElement,
  NylasBookingFormEvents
> = /*@__PURE__*/ createComponent<
  NylasBookingFormElement,
  NylasBookingFormEvents
>({
  tagName: "nylas-booking-form",
  elementClass: NylasBookingFormElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNameChanged: "nameChanged",
    onEmailChanged: "emailChanged",
    onBackButtonClicked: "backButtonClicked",
    onDetailsConfirmed: "detailsConfirmed",
    onBookingFormError: "bookingFormError",
    onBookingFormSubmitted: "bookingFormSubmitted",
  } as NylasBookingFormEvents,
  defineCustomElement: defineNylasBookingForm,
});

export type NylasBookingFormConfigEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasBookingFormConfig: StencilReactComponent<
  NylasBookingFormConfigElement,
  NylasBookingFormConfigEvents
> = /*@__PURE__*/ createComponent<
  NylasBookingFormConfigElement,
  NylasBookingFormConfigEvents
>({
  tagName: "nylas-booking-form-config",
  elementClass: NylasBookingFormConfigElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasBookingFormConfigEvents,
  defineCustomElement: defineNylasBookingFormConfig,
});

export type NylasBufferTimeEvents = {
  onValueChanged: EventName<
    NylasBufferTimeCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasBufferTime: StencilReactComponent<
  NylasBufferTimeElement,
  NylasBufferTimeEvents
> = /*@__PURE__*/ createComponent<
  NylasBufferTimeElement,
  NylasBufferTimeEvents
>({
  tagName: "nylas-buffer-time",
  elementClass: NylasBufferTimeElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasBufferTimeEvents,
  defineCustomElement: defineNylasBufferTime,
});

export type NylasCalendarPickerEvents = {
  onValueChanged: EventName<
    NylasCalendarPickerCustomEvent<{
      value: string[];
      name: string;
      valueChangedHandler?: (
        event: CustomEvent<{ value: string[]; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasCalendarPicker: StencilReactComponent<
  NylasCalendarPickerElement,
  NylasCalendarPickerEvents
> = /*@__PURE__*/ createComponent<
  NylasCalendarPickerElement,
  NylasCalendarPickerEvents
>({
  tagName: "nylas-calendar-picker",
  elementClass: NylasCalendarPickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasCalendarPickerEvents,
  defineCustomElement: defineNylasCalendarPicker,
});

export type NylasCancelBookingFormEvents = {
  onGoBackButtonClicked: EventName<CustomEvent<void>>;
  onCancelBookingFormSubmitted: EventName<
    NylasCancelBookingFormCustomEvent<{
      bookingId: string;
      action: "reject" | "cancel";
      reason: string;
      errorHandler?: (error: NylasSchedulerErrorResponse) => void;
    }>
  >;
  onTriggerValidation: EventName<CustomEvent<{}>>;
  onCancelBookedEventError: EventName<
    NylasCancelBookingFormCustomEvent<NylasSchedulerErrorResponse>
  >;
  onCancelBookingFormError: EventName<
    NylasCancelBookingFormCustomEvent<Partial<Notification>>
  >;
};

export const NylasCancelBookingForm: StencilReactComponent<
  NylasCancelBookingFormElement,
  NylasCancelBookingFormEvents
> = /*@__PURE__*/ createComponent<
  NylasCancelBookingFormElement,
  NylasCancelBookingFormEvents
>({
  tagName: "nylas-cancel-booking-form",
  elementClass: NylasCancelBookingFormElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onGoBackButtonClicked: "goBackButtonClicked",
    onCancelBookingFormSubmitted: "cancelBookingFormSubmitted",
    onTriggerValidation: "triggerValidation",
    onCancelBookedEventError: "cancelBookedEventError",
    onCancelBookingFormError: "cancelBookingFormError",
  } as NylasCancelBookingFormEvents,
  defineCustomElement: defineNylasCancelBookingForm,
});

export type NylasCancellationPolicyEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasCancellationPolicy: StencilReactComponent<
  NylasCancellationPolicyElement,
  NylasCancellationPolicyEvents
> = /*@__PURE__*/ createComponent<
  NylasCancellationPolicyElement,
  NylasCancellationPolicyEvents
>({
  tagName: "nylas-cancellation-policy",
  elementClass: NylasCancellationPolicyElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasCancellationPolicyEvents,
  defineCustomElement: defineNylasCancellationPolicy,
});

export type NylasCancelledEventCardEvents = {
  onCloseCancelEventCardClicked: EventName<
    NylasCancelledEventCardCustomEvent<{
      errorHandler?: (error: NylasSchedulerErrorResponse) => void;
    }>
  >;
  onCancelledEventCardError: EventName<
    NylasCancelledEventCardCustomEvent<NylasSchedulerErrorResponse>
  >;
};

export const NylasCancelledEventCard: StencilReactComponent<
  NylasCancelledEventCardElement,
  NylasCancelledEventCardEvents
> = /*@__PURE__*/ createComponent<
  NylasCancelledEventCardElement,
  NylasCancelledEventCardEvents
>({
  tagName: "nylas-cancelled-event-card",
  elementClass: NylasCancelledEventCardElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onCloseCancelEventCardClicked: "closeCancelEventCardClicked",
    onCancelledEventCardError: "cancelledEventCardError",
  } as NylasCancelledEventCardEvents,
  defineCustomElement: defineNylasCancelledEventCard,
});

export type NylasConfirmationEmailEvents = {
  onValueChanged: EventName<
    NylasConfirmationEmailCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasConfirmationEmail: StencilReactComponent<
  NylasConfirmationEmailElement,
  NylasConfirmationEmailEvents
> = /*@__PURE__*/ createComponent<
  NylasConfirmationEmailElement,
  NylasConfirmationEmailEvents
>({
  tagName: "nylas-confirmation-email",
  elementClass: NylasConfirmationEmailElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasConfirmationEmailEvents,
  defineCustomElement: defineNylasConfirmationEmail,
});

export type NylasConfirmedEventCardEvents = {
  onCloseConfirmEventCardClicked: EventName<
    NylasConfirmedEventCardCustomEvent<{
      errorHandler?: (error: NylasSchedulerErrorResponse) => void;
    }>
  >;
  onConfirmedEventCardError: EventName<
    NylasConfirmedEventCardCustomEvent<NylasSchedulerErrorResponse>
  >;
};

export const NylasConfirmedEventCard: StencilReactComponent<
  NylasConfirmedEventCardElement,
  NylasConfirmedEventCardEvents
> = /*@__PURE__*/ createComponent<
  NylasConfirmedEventCardElement,
  NylasConfirmedEventCardEvents
>({
  tagName: "nylas-confirmed-event-card",
  elementClass: NylasConfirmedEventCardElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onCloseConfirmEventCardClicked: "closeConfirmEventCardClicked",
    onConfirmedEventCardError: "confirmedEventCardError",
  } as NylasConfirmedEventCardEvents,
  defineCustomElement: defineNylasConfirmedEventCard,
});

export type NylasConnectedCalendarsEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasConnectedCalendars: StencilReactComponent<
  NylasConnectedCalendarsElement,
  NylasConnectedCalendarsEvents
> = /*@__PURE__*/ createComponent<
  NylasConnectedCalendarsElement,
  NylasConnectedCalendarsEvents
>({
  tagName: "nylas-connected-calendars",
  elementClass: NylasConnectedCalendarsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasConnectedCalendarsEvents,
  defineCustomElement: defineNylasConnectedCalendars,
});

export type NylasCustomBookingFlowEvents = NonNullable<unknown>;

export const NylasCustomBookingFlow: StencilReactComponent<
  NylasCustomBookingFlowElement,
  NylasCustomBookingFlowEvents
> = /*@__PURE__*/ createComponent<
  NylasCustomBookingFlowElement,
  NylasCustomBookingFlowEvents
>({
  tagName: "nylas-custom-booking-flow",
  elementClass: NylasCustomBookingFlowElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as NylasCustomBookingFlowEvents,
  defineCustomElement: defineNylasCustomBookingFlow,
});

export type NylasCustomEventSlugEvents = {
  onValueChanged: EventName<
    NylasCustomEventSlugCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasCustomEventSlug: StencilReactComponent<
  NylasCustomEventSlugElement,
  NylasCustomEventSlugEvents
> = /*@__PURE__*/ createComponent<
  NylasCustomEventSlugElement,
  NylasCustomEventSlugEvents
>({
  tagName: "nylas-custom-event-slug",
  elementClass: NylasCustomEventSlugElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasCustomEventSlugEvents,
  defineCustomElement: defineNylasCustomEventSlug,
});

export type NylasCustomizeBookingSettingsEvents = {
  onValueChanged: EventName<
    NylasCustomizeBookingSettingsCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasCustomizeBookingSettings: StencilReactComponent<
  NylasCustomizeBookingSettingsElement,
  NylasCustomizeBookingSettingsEvents
> = /*@__PURE__*/ createComponent<
  NylasCustomizeBookingSettingsElement,
  NylasCustomizeBookingSettingsEvents
>({
  tagName: "nylas-customize-booking-settings",
  elementClass: NylasCustomizeBookingSettingsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasCustomizeBookingSettingsEvents,
  defineCustomElement: defineNylasCustomizeBookingSettings,
});

export type NylasDateComponentEvents = {
  onNylasFormInputChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
      label: string;
      type: string;
      error: string;
    }>
  >;
  onNylasFormInputFocused: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
  onNylasFormInputBlurred: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasDateComponent: StencilReactComponent<
  NylasDateComponentElement,
  NylasDateComponentEvents
> = /*@__PURE__*/ createComponent<
  NylasDateComponentElement,
  NylasDateComponentEvents
>({
  tagName: "nylas-date-component",
  elementClass: NylasDateComponentElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormInputChanged: "nylasFormInputChanged",
    onNylasFormInputFocused: "nylasFormInputFocused",
    onNylasFormInputBlurred: "nylasFormInputBlurred",
  } as NylasDateComponentEvents,
  defineCustomElement: defineNylasDateComponent,
});

export type NylasDatePickerEvents = {
  onDateSelected: EventName<NylasDatePickerCustomEvent<Date>>;
  onMonthChanged: EventName<NylasDatePickerCustomEvent<Date>>;
};

export const NylasDatePicker: StencilReactComponent<
  NylasDatePickerElement,
  NylasDatePickerEvents
> = /*@__PURE__*/ createComponent<
  NylasDatePickerElement,
  NylasDatePickerEvents
>({
  tagName: "nylas-date-picker",
  elementClass: NylasDatePickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onDateSelected: "dateSelected",
    onMonthChanged: "monthChanged",
  } as NylasDatePickerEvents,
  defineCustomElement: defineNylasDatePicker,
});

export type NylasDisableEmailsEvents = {
  onValueChanged: EventName<
    NylasDisableEmailsCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasDisableEmails: StencilReactComponent<
  NylasDisableEmailsElement,
  NylasDisableEmailsEvents
> = /*@__PURE__*/ createComponent<
  NylasDisableEmailsElement,
  NylasDisableEmailsEvents
>({
  tagName: "nylas-disable-emails",
  elementClass: NylasDisableEmailsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasDisableEmailsEvents,
  defineCustomElement: defineNylasDisableEmails,
});

export type NylasEditorTabsEvents = {
  onSchedulerConfigChanged: EventName<
    NylasEditorTabsCustomEvent<SchedulerEventDetail>
  >;
  onSchedulerConfigCreated: EventName<
    NylasEditorTabsCustomEvent<SchedulerEventDetail>
  >;
  onCancelButtonClick: EventName<CustomEvent<void>>;
  onFormSubmitted: EventName<CustomEvent<void>>;
  onPreviewButtonClicked: EventName<
    NylasEditorTabsCustomEvent<HTMLNylasEditorTabsElement>
  >;
  onSchedulerEditorFormUpdated: EventName<
    CustomEvent<{ value: string; name: string }>
  >;
  onNylasSchedulerError: EventName<
    NylasEditorTabsCustomEvent<{
      notification: Notification;
      host: HTMLElement;
    }>
  >;
  onDismissNotification: EventName<
    NylasEditorTabsCustomEvent<{ id: string; host: HTMLNylasEditorTabsElement }>
  >;
};

export const NylasEditorTabs: StencilReactComponent<
  NylasEditorTabsElement,
  NylasEditorTabsEvents
> = /*@__PURE__*/ createComponent<
  NylasEditorTabsElement,
  NylasEditorTabsEvents
>({
  tagName: "nylas-editor-tabs",
  elementClass: NylasEditorTabsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onSchedulerConfigChanged: "schedulerConfigChanged",
    onSchedulerConfigCreated: "schedulerConfigCreated",
    onCancelButtonClick: "cancelButtonClick",
    onFormSubmitted: "formSubmitted",
    onPreviewButtonClicked: "previewButtonClicked",
    onSchedulerEditorFormUpdated: "schedulerEditorFormUpdated",
    onNylasSchedulerError: "nylasSchedulerError",
    onDismissNotification: "dismissNotification",
  } as NylasEditorTabsEvents,
  defineCustomElement: defineNylasEditorTabs,
});

export type NylasEditorTabsGroupEvents = {
  onSchedulerConfigChanged: EventName<
    NylasEditorTabsGroupCustomEvent<
      SchedulerGroupEventDetail & { host: HTMLNylasEditorTabsGroupElement }
    >
  >;
  onSchedulerConfigCreated: EventName<
    NylasEditorTabsGroupCustomEvent<
      SchedulerGroupEventDetail & { host: HTMLNylasEditorTabsGroupElement }
    >
  >;
  onCancelButtonClick: EventName<CustomEvent<void>>;
  onFormSubmitted: EventName<CustomEvent<void>>;
  onPreviewButtonClicked: EventName<
    NylasEditorTabsGroupCustomEvent<HTMLNylasEditorTabsGroupElement>
  >;
  onSchedulerEditorFormUpdated: EventName<
    CustomEvent<{ value: string; name: string }>
  >;
  onGroupEventCreateTriggered: EventName<
    NylasEditorTabsGroupCustomEvent<{
      groupEvent: Partial<GroupEvent>;
      configId: string;
      host: HTMLNylasEditorTabsGroupElement;
    }>
  >;
  onGroupEventUpdateTriggered: EventName<
    NylasEditorTabsGroupCustomEvent<{
      groupEvent: GroupEvent;
      chosenOption: RecurrenceUpdateOption;
      configId: string;
      host: HTMLNylasEditorTabsGroupElement;
    }>
  >;
  onGroupEventDeleteTriggered: EventName<
    NylasEditorTabsGroupCustomEvent<{
      groupEvent: GroupEvent;
      chosenOption: RecurrenceDeleteOption;
      configId: string;
      host: HTMLNylasEditorTabsGroupElement;
    }>
  >;
  onGroupEventImportTriggered: EventName<
    NylasEditorTabsGroupCustomEvent<{
      groupEvent: ImportGroupEventDetails;
      configId: string;
      host: HTMLNylasEditorTabsGroupElement;
    }>
  >;
  onSaveGroupEventChangesError: EventName<
    NylasEditorTabsGroupCustomEvent<{
      error: string;
      configId: string;
      host: HTMLNylasEditorTabsGroupElement;
    }>
  >;
  onNylasSchedulerError: EventName<
    NylasEditorTabsGroupCustomEvent<{
      notification: Notification;
      host: HTMLElement;
    }>
  >;
  onDismissNotification: EventName<
    NylasEditorTabsGroupCustomEvent<{
      id: string;
      host: HTMLNylasEditorTabsGroupElement;
    }>
  >;
};

export const NylasEditorTabsGroup: StencilReactComponent<
  NylasEditorTabsGroupElement,
  NylasEditorTabsGroupEvents
> = /*@__PURE__*/ createComponent<
  NylasEditorTabsGroupElement,
  NylasEditorTabsGroupEvents
>({
  tagName: "nylas-editor-tabs-group",
  elementClass: NylasEditorTabsGroupElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onSchedulerConfigChanged: "schedulerConfigChanged",
    onSchedulerConfigCreated: "schedulerConfigCreated",
    onCancelButtonClick: "cancelButtonClick",
    onFormSubmitted: "formSubmitted",
    onPreviewButtonClicked: "previewButtonClicked",
    onSchedulerEditorFormUpdated: "schedulerEditorFormUpdated",
    onGroupEventCreateTriggered: "groupEventCreateTriggered",
    onGroupEventUpdateTriggered: "groupEventUpdateTriggered",
    onGroupEventDeleteTriggered: "groupEventDeleteTriggered",
    onGroupEventImportTriggered: "groupEventImportTriggered",
    onSaveGroupEventChangesError: "saveGroupEventChangesError",
    onNylasSchedulerError: "nylasSchedulerError",
    onDismissNotification: "dismissNotification",
  } as NylasEditorTabsGroupEvents,
  defineCustomElement: defineNylasEditorTabsGroup,
});

export type NylasEventCalendarEvents = {
  onFetchMasterGroupEvent: EventName<CustomEvent<string>>;
  onSaveGroupEventChanges: EventName<
    NylasEventCalendarCustomEvent<{
      data: GroupEventAPIData;
      action: "this" | "future" | "all";
    }>
  >;
  onDeleteGroupEvent: EventName<
    NylasEventCalendarCustomEvent<{
      data: GroupEventAPIData;
      action: "this" | "future" | "all";
    }>
  >;
  onGroupEventSelected: EventName<
    NylasEventCalendarCustomEvent<GroupEventAPIData>
  >;
  onCreateGroupEvent: EventName<
    NylasEventCalendarCustomEvent<CreateGroupEventFormState>
  >;
  onCalendarViewChanged: EventName<
    CustomEvent<{ startTime: number; endTime: number }>
  >;
  onPreviosNextClicked: EventName<
    CustomEvent<{
      direction: "prev" | "next";
      view: "day" | "week" | "month";
      currentViewRange: { startTime: number; endTime: number };
    }>
  >;
  onSetCalendarViewDateRange: EventName<
    CustomEvent<{ startTime: number; endTime: number }>
  >;
  onImportGroupEvent: EventName<
    CustomEvent<{
      event_id: string;
      calendar_id: string;
    }>
  >;
};

export const NylasEventCalendar: StencilReactComponent<
  NylasEventCalendarElement,
  NylasEventCalendarEvents
> = /*@__PURE__*/ createComponent<
  NylasEventCalendarElement,
  NylasEventCalendarEvents
>({
  tagName: "nylas-event-calendar",
  elementClass: NylasEventCalendarElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onFetchMasterGroupEvent: "fetchMasterGroupEvent",
    onSaveGroupEventChanges: "saveGroupEventChanges",
    onDeleteGroupEvent: "deleteGroupEvent",
    onGroupEventSelected: "groupEventSelected",
    onCreateGroupEvent: "createGroupEvent",
    onCalendarViewChanged: "calendarViewChanged",
    onPreviosNextClicked: "previosNextClicked",
    onSetCalendarViewDateRange: "setCalendarViewDateRange",
    onImportGroupEvent: "importGroupEvent",
  } as NylasEventCalendarEvents,
  defineCustomElement: defineNylasEventCalendar,
});

export type NylasEventCapacityEvents = {
  onValueChanged: EventName<
    NylasEventCapacityCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasEventCapacity: StencilReactComponent<
  NylasEventCapacityElement,
  NylasEventCapacityEvents
> = /*@__PURE__*/ createComponent<
  NylasEventCapacityElement,
  NylasEventCapacityEvents
>({
  tagName: "nylas-event-capacity",
  elementClass: NylasEventCapacityElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasEventCapacityEvents,
  defineCustomElement: defineNylasEventCapacity,
});

export type NylasEventDescriptionEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasEventDescription: StencilReactComponent<
  NylasEventDescriptionElement,
  NylasEventDescriptionEvents
> = /*@__PURE__*/ createComponent<
  NylasEventDescriptionElement,
  NylasEventDescriptionEvents
>({
  tagName: "nylas-event-description",
  elementClass: NylasEventDescriptionElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasEventDescriptionEvents,
  defineCustomElement: defineNylasEventDescription,
});

export type NylasEventDurationEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasEventDuration: StencilReactComponent<
  NylasEventDurationElement,
  NylasEventDurationEvents
> = /*@__PURE__*/ createComponent<
  NylasEventDurationElement,
  NylasEventDurationEvents
>({
  tagName: "nylas-event-duration",
  elementClass: NylasEventDurationElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasEventDurationEvents,
  defineCustomElement: defineNylasEventDuration,
});

export type NylasEventInfoEvents = NonNullable<unknown>;

export const NylasEventInfo: StencilReactComponent<
  NylasEventInfoElement,
  NylasEventInfoEvents
> = /*@__PURE__*/ createComponent<NylasEventInfoElement, NylasEventInfoEvents>({
  tagName: "nylas-event-info",
  elementClass: NylasEventInfoElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as NylasEventInfoEvents,
  defineCustomElement: defineNylasEventInfo,
});

export type NylasEventLimitsEvents = NonNullable<unknown>;

export const NylasEventLimits: StencilReactComponent<
  NylasEventLimitsElement,
  NylasEventLimitsEvents
> = /*@__PURE__*/ createComponent<
  NylasEventLimitsElement,
  NylasEventLimitsEvents
>({
  tagName: "nylas-event-limits",
  elementClass: NylasEventLimitsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as NylasEventLimitsEvents,
  defineCustomElement: defineNylasEventLimits,
});

export type NylasEventLocationEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasEventLocation: StencilReactComponent<
  NylasEventLocationElement,
  NylasEventLocationEvents
> = /*@__PURE__*/ createComponent<
  NylasEventLocationElement,
  NylasEventLocationEvents
>({
  tagName: "nylas-event-location",
  elementClass: NylasEventLocationElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasEventLocationEvents,
  defineCustomElement: defineNylasEventLocation,
});

export type NylasEventTimeslotEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
  onTimeWindowFormError: EventName<
    CustomEvent<{
      key: string;
      message: string;
      uniqueIdentifier?: string;
    }>
  >;
  onDateTimeInputError: EventName<
    CustomEvent<{
      key: string;
      message: string;
    }>
  >;
};

export const NylasEventTimeslot: StencilReactComponent<
  NylasEventTimeslotElement,
  NylasEventTimeslotEvents
> = /*@__PURE__*/ createComponent<
  NylasEventTimeslotElement,
  NylasEventTimeslotEvents
>({
  tagName: "nylas-event-timeslot",
  elementClass: NylasEventTimeslotElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
    onTimeWindowFormError: "timeWindowFormError",
    onDateTimeInputError: "dateTimeInputError",
  } as NylasEventTimeslotEvents,
  defineCustomElement: defineNylasEventTimeslot,
});

export type NylasEventTitleEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasEventTitle: StencilReactComponent<
  NylasEventTitleElement,
  NylasEventTitleEvents
> = /*@__PURE__*/ createComponent<
  NylasEventTitleElement,
  NylasEventTitleEvents
>({
  tagName: "nylas-event-title",
  elementClass: NylasEventTitleElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasEventTitleEvents,
  defineCustomElement: defineNylasEventTitle,
});

export type NylasFeedbackFormEvents = {
  onFeedbackModalClosed: EventName<CustomEvent<void>>;
  onFeedbackSubmitted: EventName<CustomEvent<{ feedback: string }>>;
  onTriggerValidation: EventName<CustomEvent<void>>;
};

export const NylasFeedbackForm: StencilReactComponent<
  NylasFeedbackFormElement,
  NylasFeedbackFormEvents
> = /*@__PURE__*/ createComponent<
  NylasFeedbackFormElement,
  NylasFeedbackFormEvents
>({
  tagName: "nylas-feedback-form",
  elementClass: NylasFeedbackFormElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onFeedbackModalClosed: "feedbackModalClosed",
    onFeedbackSubmitted: "feedbackSubmitted",
    onTriggerValidation: "triggerValidation",
  } as NylasFeedbackFormEvents,
  defineCustomElement: defineNylasFeedbackForm,
});

export type NylasFormCardEvents = NonNullable<unknown>;

export const NylasFormCard: StencilReactComponent<
  NylasFormCardElement,
  NylasFormCardEvents
> = /*@__PURE__*/ createComponent<NylasFormCardElement, NylasFormCardEvents>({
  tagName: "nylas-form-card",
  elementClass: NylasFormCardElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as NylasFormCardEvents,
  defineCustomElement: defineNylasFormCard,
});

export type NylasLimitFutureBookingsEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasLimitFutureBookings: StencilReactComponent<
  NylasLimitFutureBookingsElement,
  NylasLimitFutureBookingsEvents
> = /*@__PURE__*/ createComponent<
  NylasLimitFutureBookingsElement,
  NylasLimitFutureBookingsEvents
>({
  tagName: "nylas-limit-future-bookings",
  elementClass: NylasLimitFutureBookingsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasLimitFutureBookingsEvents,
  defineCustomElement: defineNylasLimitFutureBookings,
});

export type NylasListConfigurationsEvents = {
  onInitListConfigurations: EventName<
    NylasListConfigurationsCustomEvent<{
      host: HTMLNylasListConfigurationsElement;
      cursor?: string;
    }>
  >;
  onCreateButtonClick: EventName<
    NylasListConfigurationsCustomEvent<HTMLNylasListConfigurationsElement>
  >;
  onEditButtonClick: EventName<
    NylasListConfigurationsCustomEvent<{
      host: HTMLNylasListConfigurationsElement;
      configuration: Configuration | GroupConfiguration;
    }>
  >;
  onDeleteButtonClick: EventName<
    NylasListConfigurationsCustomEvent<{
      host: HTMLNylasListConfigurationsElement;
      configuration: Configuration | GroupConfiguration;
    }>
  >;
  onNylasSchedulerError: EventName<
    NylasListConfigurationsCustomEvent<{
      notification: Notification;
      host: HTMLElement;
    }>
  >;
  onDismissNotification: EventName<
    NylasListConfigurationsCustomEvent<{
      id: string;
      host: HTMLNylasListConfigurationsElement;
    }>
  >;
};

export const NylasListConfigurations: StencilReactComponent<
  NylasListConfigurationsElement,
  NylasListConfigurationsEvents
> = /*@__PURE__*/ createComponent<
  NylasListConfigurationsElement,
  NylasListConfigurationsEvents
>({
  tagName: "nylas-list-configurations",
  elementClass: NylasListConfigurationsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onInitListConfigurations: "initListConfigurations",
    onCreateButtonClick: "createButtonClick",
    onEditButtonClick: "editButtonClick",
    onDeleteButtonClick: "deleteButtonClick",
    onNylasSchedulerError: "nylasSchedulerError",
    onDismissNotification: "dismissNotification",
  } as NylasListConfigurationsEvents,
  defineCustomElement: defineNylasListConfigurations,
});

export type NylasLocaleSwitchEvents = {
  onTimezoneChanged: EventName<CustomEvent<string>>;
  onLanguageChanged: EventName<CustomEvent<string>>;
};

export const NylasLocaleSwitch: StencilReactComponent<
  NylasLocaleSwitchElement,
  NylasLocaleSwitchEvents
> = /*@__PURE__*/ createComponent<
  NylasLocaleSwitchElement,
  NylasLocaleSwitchEvents
>({
  tagName: "nylas-locale-switch",
  elementClass: NylasLocaleSwitchElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onTimezoneChanged: "timezoneChanged",
    onLanguageChanged: "languageChanged",
  } as NylasLocaleSwitchEvents,
  defineCustomElement: defineNylasLocaleSwitch,
});

export type NylasLogoEvents = NonNullable<unknown>;

export const NylasLogo: StencilReactComponent<
  NylasLogoElement,
  NylasLogoEvents
> = /*@__PURE__*/ createComponent<NylasLogoElement, NylasLogoEvents>({
  tagName: "nylas-logo",
  elementClass: NylasLogoElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as NylasLogoEvents,
  defineCustomElement: defineNylasLogo,
});

export type NylasMinBookingNoticeEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasMinBookingNotice: StencilReactComponent<
  NylasMinBookingNoticeElement,
  NylasMinBookingNoticeEvents
> = /*@__PURE__*/ createComponent<
  NylasMinBookingNoticeElement,
  NylasMinBookingNoticeEvents
>({
  tagName: "nylas-min-booking-notice",
  elementClass: NylasMinBookingNoticeElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasMinBookingNoticeEvents,
  defineCustomElement: defineNylasMinBookingNotice,
});

export type NylasMinCancellationNoticeEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasMinCancellationNotice: StencilReactComponent<
  NylasMinCancellationNoticeElement,
  NylasMinCancellationNoticeEvents
> = /*@__PURE__*/ createComponent<
  NylasMinCancellationNoticeElement,
  NylasMinCancellationNoticeEvents
>({
  tagName: "nylas-min-cancellation-notice",
  elementClass: NylasMinCancellationNoticeElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasMinCancellationNoticeEvents,
  defineCustomElement: defineNylasMinCancellationNotice,
});

export type NylasNotetakerConfigEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
  onNotetakerError: EventName<
    NylasNotetakerConfigCustomEvent<{
      error: string;
      reason: string;
      context?: Record<string, any>;
    }>
  >;
};

export const NylasNotetakerConfig: StencilReactComponent<
  NylasNotetakerConfigElement,
  NylasNotetakerConfigEvents
> = /*@__PURE__*/ createComponent<
  NylasNotetakerConfigElement,
  NylasNotetakerConfigEvents
>({
  tagName: "nylas-notetaker-config",
  elementClass: NylasNotetakerConfigElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
    onNotetakerError: "notetakerError",
  } as NylasNotetakerConfigEvents,
  defineCustomElement: defineNylasNotetakerConfig,
});

export type NylasNotificationEvents = NonNullable<unknown>;

export const NylasNotification: StencilReactComponent<
  NylasNotificationElement,
  NylasNotificationEvents
> = /*@__PURE__*/ createComponent<
  NylasNotificationElement,
  NylasNotificationEvents
>({
  tagName: "nylas-notification",
  elementClass: NylasNotificationElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as NylasNotificationEvents,
  defineCustomElement: defineNylasNotification,
});

export type NylasOnlySpecificTimeAvailabilityEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasOnlySpecificTimeAvailability: StencilReactComponent<
  NylasOnlySpecificTimeAvailabilityElement,
  NylasOnlySpecificTimeAvailabilityEvents
> = /*@__PURE__*/ createComponent<
  NylasOnlySpecificTimeAvailabilityElement,
  NylasOnlySpecificTimeAvailabilityEvents
>({
  tagName: "nylas-only-specific-time-availability",
  elementClass: NylasOnlySpecificTimeAvailabilityElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasOnlySpecificTimeAvailabilityEvents,
  defineCustomElement: defineNylasOnlySpecificTimeAvailability,
});

export type NylasOrganizerConfirmationCardEvents = {
  onRejectBookingButtonClicked: EventName<
    NylasOrganizerConfirmationCardCustomEvent<{
      bookingId: string;
      host: HTMLNylasOrganizerConfirmationCardElement;
    }>
  >;
  onConfirmBookingButtonClicked: EventName<
    NylasOrganizerConfirmationCardCustomEvent<{
      bookingId: string;
      host: HTMLNylasOrganizerConfirmationCardElement;
      errorHandler?: (error: NylasSchedulerErrorResponse) => void;
    }>
  >;
  onConfirmBookingError: EventName<
    NylasOrganizerConfirmationCardCustomEvent<NylasSchedulerErrorResponse>
  >;
};

export const NylasOrganizerConfirmationCard: StencilReactComponent<
  NylasOrganizerConfirmationCardElement,
  NylasOrganizerConfirmationCardEvents
> = /*@__PURE__*/ createComponent<
  NylasOrganizerConfirmationCardElement,
  NylasOrganizerConfirmationCardEvents
>({
  tagName: "nylas-organizer-confirmation-card",
  elementClass: NylasOrganizerConfirmationCardElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onRejectBookingButtonClicked: "rejectBookingButtonClicked",
    onConfirmBookingButtonClicked: "confirmBookingButtonClicked",
    onConfirmBookingError: "confirmBookingError",
  } as NylasOrganizerConfirmationCardEvents,
  defineCustomElement: defineNylasOrganizerConfirmationCard,
});

export type NylasPageNameEvents = {
  onValueChanged: EventName<
    NylasPageNameCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasPageName: StencilReactComponent<
  NylasPageNameElement,
  NylasPageNameEvents
> = /*@__PURE__*/ createComponent<NylasPageNameElement, NylasPageNameEvents>({
  tagName: "nylas-page-name",
  elementClass: NylasPageNameElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasPageNameEvents,
  defineCustomElement: defineNylasPageName,
});

export type NylasPageStylingEvents = {
  onValueChanged: EventName<
    NylasPageStylingCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
  onBookingFormSubmitted: EventName<CustomEvent<void>>;
};

export const NylasPageStyling: StencilReactComponent<
  NylasPageStylingElement,
  NylasPageStylingEvents
> = /*@__PURE__*/ createComponent<
  NylasPageStylingElement,
  NylasPageStylingEvents
>({
  tagName: "nylas-page-styling",
  elementClass: NylasPageStylingElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
    onBookingFormSubmitted: "bookingFormSubmitted",
  } as NylasPageStylingEvents,
  defineCustomElement: defineNylasPageStyling,
});

export type NylasParticipantBookingCalendarsEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasParticipantBookingCalendars: StencilReactComponent<
  NylasParticipantBookingCalendarsElement,
  NylasParticipantBookingCalendarsEvents
> = /*@__PURE__*/ createComponent<
  NylasParticipantBookingCalendarsElement,
  NylasParticipantBookingCalendarsEvents
>({
  tagName: "nylas-participant-booking-calendars",
  elementClass: NylasParticipantBookingCalendarsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasParticipantBookingCalendarsEvents,
  defineCustomElement: defineNylasParticipantBookingCalendars,
});

export type NylasParticipantsCustomAvailabilityEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasParticipantsCustomAvailability: StencilReactComponent<
  NylasParticipantsCustomAvailabilityElement,
  NylasParticipantsCustomAvailabilityEvents
> = /*@__PURE__*/ createComponent<
  NylasParticipantsCustomAvailabilityElement,
  NylasParticipantsCustomAvailabilityEvents
>({
  tagName: "nylas-participants-custom-availability",
  elementClass: NylasParticipantsCustomAvailabilityElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasParticipantsCustomAvailabilityEvents,
  defineCustomElement: defineNylasParticipantsCustomAvailability,
});

export type NylasReminderEmailsEvents = {
  onValueChanged: EventName<
    NylasReminderEmailsCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
  onNylasSuggestReminderMinutes: EventName<CustomEvent<{ minutes: number }>>;
};

export const NylasReminderEmails: StencilReactComponent<
  NylasReminderEmailsElement,
  NylasReminderEmailsEvents
> = /*@__PURE__*/ createComponent<
  NylasReminderEmailsElement,
  NylasReminderEmailsEvents
>({
  tagName: "nylas-reminder-emails",
  elementClass: NylasReminderEmailsElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
    onNylasSuggestReminderMinutes: "nylasSuggestReminderMinutes",
  } as NylasReminderEmailsEvents,
  defineCustomElement: defineNylasReminderEmails,
});

export type NylasReminderTimeEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasReminderTime: StencilReactComponent<
  NylasReminderTimeElement,
  NylasReminderTimeEvents
> = /*@__PURE__*/ createComponent<
  NylasReminderTimeElement,
  NylasReminderTimeEvents
>({
  tagName: "nylas-reminder-time",
  elementClass: NylasReminderTimeElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasReminderTimeEvents,
  defineCustomElement: defineNylasReminderTime,
});

export type NylasSchedulerEditorEvents = {
  onInit: EventName<
    NylasSchedulerEditorCustomEvent<HTMLNylasSchedulerEditorElement>
  >;
  onLoggedIn: EventName<
    NylasSchedulerEditorCustomEvent<HTMLNylasSchedulerEditorElement>
  >;
  onLoggedOut: EventName<
    NylasSchedulerEditorCustomEvent<HTMLNylasSchedulerEditorElement>
  >;
  onSchedulerConfigCloseClicked: EventName<
    NylasSchedulerEditorCustomEvent<HTMLNylasSchedulerEditorElement>
  >;
  onNylasSchedulerEditorError: EventName<
    NylasSchedulerEditorCustomEvent<{
      notification: Notification;
      host: HTMLElement;
    }>
  >;
};

export const NylasSchedulerEditor: StencilReactComponent<
  NylasSchedulerEditorElement,
  NylasSchedulerEditorEvents
> = /*@__PURE__*/ createComponent<
  NylasSchedulerEditorElement,
  NylasSchedulerEditorEvents
>({
  tagName: "nylas-scheduler-editor",
  elementClass: NylasSchedulerEditorElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onInit: "init",
    onLoggedIn: "loggedIn",
    onLoggedOut: "loggedOut",
    onSchedulerConfigCloseClicked: "schedulerConfigCloseClicked",
    onNylasSchedulerEditorError: "nylasSchedulerEditorError",
  } as NylasSchedulerEditorEvents,
  defineCustomElement: defineNylasSchedulerEditor,
});

export type NylasSchedulingEvents = {
  onInit: EventName<NylasSchedulingCustomEvent<HTMLNylasSchedulingElement>>;
  onSchedulerWillLoad: EventName<
    NylasSchedulingCustomEvent<HTMLNylasSchedulingElement>
  >;
  onSchedulerDidLoad: EventName<
    NylasSchedulingCustomEvent<HTMLNylasSchedulingElement>
  >;
  onNylasSchedulerError: EventName<
    NylasSchedulingCustomEvent<{
      notification: Notification;
      host: HTMLElement;
    }>
  >;
  onNylasSchedulerInfo: EventName<
    NylasSchedulingCustomEvent<{
      notification: Notification;
      host: HTMLElement;
    }>
  >;
  onConfigSettingsLoaded: EventName<
    NylasSchedulingCustomEvent<{
      settings: NylasSchedulerResponse<UISettingsResponse>;
    }>
  >;
  onBookingRefExtracted: EventName<
    CustomEvent<{ configurationId: string; bookingId: string; salt?: string }>
  >;
  onBookedEventInfo: EventName<
    NylasSchedulingCustomEvent<NylasSchedulerResponse<BookedEventInfo>>
  >;
};

export const NylasScheduling: StencilReactComponent<
  NylasSchedulingElement,
  NylasSchedulingEvents
> = /*@__PURE__*/ createComponent<
  NylasSchedulingElement,
  NylasSchedulingEvents
>({
  tagName: "nylas-scheduling",
  elementClass: NylasSchedulingElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onInit: "init",
    onSchedulerWillLoad: "schedulerWillLoad",
    onSchedulerDidLoad: "schedulerDidLoad",
    onNylasSchedulerError: "nylasSchedulerError",
    onNylasSchedulerInfo: "nylasSchedulerInfo",
    onConfigSettingsLoaded: "configSettingsLoaded",
    onBookingRefExtracted: "bookingRefExtracted",
    onBookedEventInfo: "bookedEventInfo",
  } as NylasSchedulingEvents,
  defineCustomElement: defineNylasScheduling,
});

export type NylasSchedulingMethodEvents = {
  onValueChanged: EventName<
    NylasSchedulingMethodCustomEvent<{
      value: string;
      name: string;
      valueChanged?: (
        event: CustomEvent<{ value: string; name: string }>,
      ) => void;
    }>
  >;
};

export const NylasSchedulingMethod: StencilReactComponent<
  NylasSchedulingMethodElement,
  NylasSchedulingMethodEvents
> = /*@__PURE__*/ createComponent<
  NylasSchedulingMethodElement,
  NylasSchedulingMethodEvents
>({
  tagName: "nylas-scheduling-method",
  elementClass: NylasSchedulingMethodElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasSchedulingMethodEvents,
  defineCustomElement: defineNylasSchedulingMethod,
});

export type NylasSelectEventTypeEvents = {
  onReturnToAllSchedulingPagesEvent: EventName<CustomEvent<void>>;
  onCreateEventTypeSelected: EventName<
    NylasSelectEventTypeCustomEvent<{ eventType: CONFIGURATION_EVENT_TYPE }>
  >;
};

export const NylasSelectEventType: StencilReactComponent<
  NylasSelectEventTypeElement,
  NylasSelectEventTypeEvents
> = /*@__PURE__*/ createComponent<
  NylasSelectEventTypeElement,
  NylasSelectEventTypeEvents
>({
  tagName: "nylas-select-event-type",
  elementClass: NylasSelectEventTypeElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onReturnToAllSchedulingPagesEvent: "returnToAllSchedulingPagesEvent",
    onCreateEventTypeSelected: "createEventTypeSelected",
  } as NylasSelectEventTypeEvents,
  defineCustomElement: defineNylasSelectEventType,
});

export type NylasSelectedEventCardEvents = NonNullable<unknown>;

export const NylasSelectedEventCard: StencilReactComponent<
  NylasSelectedEventCardElement,
  NylasSelectedEventCardEvents
> = /*@__PURE__*/ createComponent<
  NylasSelectedEventCardElement,
  NylasSelectedEventCardEvents
>({
  tagName: "nylas-selected-event-card",
  elementClass: NylasSelectedEventCardElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as NylasSelectedEventCardEvents,
  defineCustomElement: defineNylasSelectedEventCard,
});

export type NylasSpecificTimeAvailabilityPickerEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasSpecificTimeAvailabilityPicker: StencilReactComponent<
  NylasSpecificTimeAvailabilityPickerElement,
  NylasSpecificTimeAvailabilityPickerEvents
> = /*@__PURE__*/ createComponent<
  NylasSpecificTimeAvailabilityPickerElement,
  NylasSpecificTimeAvailabilityPickerEvents
>({
  tagName: "nylas-specific-time-availability-picker",
  elementClass: NylasSpecificTimeAvailabilityPickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onValueChanged: "valueChanged",
  } as NylasSpecificTimeAvailabilityPickerEvents,
  defineCustomElement: defineNylasSpecificTimeAvailabilityPicker,
});

export type NylasTimeWindowPickerEvents = {
  onTimeChange: EventName<
    CustomEvent<{
      key: string;
      value: string;
    }>
  >;
  onTimeWindowFormError: EventName<
    CustomEvent<{
      key: string;
      message: string;
    }>
  >;
};

export const NylasTimeWindowPicker: StencilReactComponent<
  NylasTimeWindowPickerElement,
  NylasTimeWindowPickerEvents
> = /*@__PURE__*/ createComponent<
  NylasTimeWindowPickerElement,
  NylasTimeWindowPickerEvents
>({
  tagName: "nylas-time-window-picker",
  elementClass: NylasTimeWindowPickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onTimeChange: "timeChange",
    onTimeWindowFormError: "timeWindowFormError",
  } as NylasTimeWindowPickerEvents,
  defineCustomElement: defineNylasTimeWindowPicker,
});

export type NylasTimeslotIntervalEvents = {
  onValueChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
    }>
  >;
};

export const NylasTimeslotInterval: StencilReactComponent<
  NylasTimeslotIntervalElement,
  NylasTimeslotIntervalEvents
> = /*@__PURE__*/ createComponent<
  NylasTimeslotIntervalElement,
  NylasTimeslotIntervalEvents
>({
  tagName: "nylas-timeslot-interval",
  elementClass: NylasTimeslotIntervalElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: { onValueChanged: "valueChanged" } as NylasTimeslotIntervalEvents,
  defineCustomElement: defineNylasTimeslotInterval,
});

export type NylasTimeslotPickerEvents = {
  onTimeslotSelected: EventName<NylasTimeslotPickerCustomEvent<Timeslot>>;
  onTimeslotConfirmed: EventName<
    NylasTimeslotPickerCustomEvent<{
      timeslot: Timeslot;
      host: HTMLNylasTimeslotPickerElement;
    }>
  >;
  onValidateTimeslotError: EventName<
    CustomEvent<{ error: string; type: "error" | "info" }>
  >;
};

export const NylasTimeslotPicker: StencilReactComponent<
  NylasTimeslotPickerElement,
  NylasTimeslotPickerEvents
> = /*@__PURE__*/ createComponent<
  NylasTimeslotPickerElement,
  NylasTimeslotPickerEvents
>({
  tagName: "nylas-timeslot-picker",
  elementClass: NylasTimeslotPickerElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onTimeslotSelected: "timeslotSelected",
    onTimeslotConfirmed: "timeslotConfirmed",
    onValidateTimeslotError: "validateTimeslotError",
  } as NylasTimeslotPickerEvents,
  defineCustomElement: defineNylasTimeslotPicker,
});

export type PaintbrushFillIconEvents = NonNullable<unknown>;

export const PaintbrushFillIcon: StencilReactComponent<
  PaintbrushFillIconElement,
  PaintbrushFillIconEvents
> = /*@__PURE__*/ createComponent<
  PaintbrushFillIconElement,
  PaintbrushFillIconEvents
>({
  tagName: "paintbrush-fill-icon",
  elementClass: PaintbrushFillIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as PaintbrushFillIconEvents,
  defineCustomElement: definePaintbrushFillIcon,
});

export type PaintbrushIconEvents = NonNullable<unknown>;

export const PaintbrushIcon: StencilReactComponent<
  PaintbrushIconElement,
  PaintbrushIconEvents
> = /*@__PURE__*/ createComponent<PaintbrushIconElement, PaintbrushIconEvents>({
  tagName: "paintbrush-icon",
  elementClass: PaintbrushIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as PaintbrushIconEvents,
  defineCustomElement: definePaintbrushIcon,
});

export type PeopleIconEvents = NonNullable<unknown>;

export const PeopleIcon: StencilReactComponent<
  PeopleIconElement,
  PeopleIconEvents
> = /*@__PURE__*/ createComponent<PeopleIconElement, PeopleIconEvents>({
  tagName: "people-icon",
  elementClass: PeopleIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as PeopleIconEvents,
  defineCustomElement: definePeopleIcon,
});

export type PersonClipboardIconEvents = NonNullable<unknown>;

export const PersonClipboardIcon: StencilReactComponent<
  PersonClipboardIconElement,
  PersonClipboardIconEvents
> = /*@__PURE__*/ createComponent<
  PersonClipboardIconElement,
  PersonClipboardIconEvents
>({
  tagName: "person-clipboard-icon",
  elementClass: PersonClipboardIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as PersonClipboardIconEvents,
  defineCustomElement: definePersonClipboardIcon,
});

export type PersonIconEvents = NonNullable<unknown>;

export const PersonIcon: StencilReactComponent<
  PersonIconElement,
  PersonIconEvents
> = /*@__PURE__*/ createComponent<PersonIconElement, PersonIconEvents>({
  tagName: "person-icon",
  elementClass: PersonIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as PersonIconEvents,
  defineCustomElement: definePersonIcon,
});

export type PlayIconEvents = NonNullable<unknown>;

export const PlayIcon: StencilReactComponent<PlayIconElement, PlayIconEvents> =
  /*@__PURE__*/ createComponent<PlayIconElement, PlayIconEvents>({
    tagName: "play-icon",
    elementClass: PlayIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as PlayIconEvents,
    defineCustomElement: definePlayIcon,
  });

export type PlusIconEvents = NonNullable<unknown>;

export const PlusIcon: StencilReactComponent<PlusIconElement, PlusIconEvents> =
  /*@__PURE__*/ createComponent<PlusIconElement, PlusIconEvents>({
    tagName: "plus-icon",
    elementClass: PlusIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as PlusIconEvents,
    defineCustomElement: definePlusIcon,
  });

export type RadioButtonGroupEvents = {
  onNylasFormRadioChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
      label?: string;
    }>
  >;
};

export const RadioButtonGroup: StencilReactComponent<
  RadioButtonGroupElement,
  RadioButtonGroupEvents
> = /*@__PURE__*/ createComponent<
  RadioButtonGroupElement,
  RadioButtonGroupEvents
>({
  tagName: "radio-button-group",
  elementClass: RadioButtonGroupElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormRadioChanged: "nylasFormRadioChanged",
  } as RadioButtonGroupEvents,
  defineCustomElement: defineRadioButtonGroup,
});

export type RefreshIconEvents = NonNullable<unknown>;

export const RefreshIcon: StencilReactComponent<
  RefreshIconElement,
  RefreshIconEvents
> = /*@__PURE__*/ createComponent<RefreshIconElement, RefreshIconEvents>({
  tagName: "refresh-icon",
  elementClass: RefreshIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as RefreshIconEvents,
  defineCustomElement: defineRefreshIcon,
});

export type ReplyAllIconEvents = NonNullable<unknown>;

export const ReplyAllIcon: StencilReactComponent<
  ReplyAllIconElement,
  ReplyAllIconEvents
> = /*@__PURE__*/ createComponent<ReplyAllIconElement, ReplyAllIconEvents>({
  tagName: "reply-all-icon",
  elementClass: ReplyAllIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ReplyAllIconEvents,
  defineCustomElement: defineReplyAllIcon,
});

export type ReplyIconEvents = NonNullable<unknown>;

export const ReplyIcon: StencilReactComponent<
  ReplyIconElement,
  ReplyIconEvents
> = /*@__PURE__*/ createComponent<ReplyIconElement, ReplyIconEvents>({
  tagName: "reply-icon",
  elementClass: ReplyIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as ReplyIconEvents,
  defineCustomElement: defineReplyIcon,
});

export type SearchIconEvents = NonNullable<unknown>;

export const SearchIcon: StencilReactComponent<
  SearchIconElement,
  SearchIconEvents
> = /*@__PURE__*/ createComponent<SearchIconElement, SearchIconEvents>({
  tagName: "search-icon",
  elementClass: SearchIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as SearchIconEvents,
  defineCustomElement: defineSearchIcon,
});

export type SelectDropdownEvents = {
  onNylasFormDropdownChanged: EventName<
    SelectDropdownCustomEvent<{
      value: DropdownOption["value"];
      name: string;
      error?: string;
      label?: string;
    }>
  >;
  onNylasFormDropdownDefaultSelected: EventName<
    SelectDropdownCustomEvent<{
      value: DropdownOption["value"];
      name: string;
      error?: string;
      label?: string;
    }>
  >;
};

export const SelectDropdown: StencilReactComponent<
  SelectDropdownElement,
  SelectDropdownEvents
> = /*@__PURE__*/ createComponent<SelectDropdownElement, SelectDropdownEvents>({
  tagName: "select-dropdown",
  elementClass: SelectDropdownElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormDropdownChanged: "nylasFormDropdownChanged",
    onNylasFormDropdownDefaultSelected: "nylasFormDropdownDefaultSelected",
  } as SelectDropdownEvents,
  defineCustomElement: defineSelectDropdown,
});

export type SentIconEvents = NonNullable<unknown>;

export const SentIcon: StencilReactComponent<SentIconElement, SentIconEvents> =
  /*@__PURE__*/ createComponent<SentIconElement, SentIconEvents>({
    tagName: "sent-icon",
    elementClass: SentIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as SentIconEvents,
    defineCustomElement: defineSentIcon,
  });

export type SpamIconEvents = NonNullable<unknown>;

export const SpamIcon: StencilReactComponent<SpamIconElement, SpamIconEvents> =
  /*@__PURE__*/ createComponent<SpamIconElement, SpamIconEvents>({
    tagName: "spam-icon",
    elementClass: SpamIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as SpamIconEvents,
    defineCustomElement: defineSpamIcon,
  });

export type StarIconEvents = NonNullable<unknown>;

export const StarIcon: StencilReactComponent<StarIconElement, StarIconEvents> =
  /*@__PURE__*/ createComponent<StarIconElement, StarIconEvents>({
    tagName: "star-icon",
    elementClass: StarIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as StarIconEvents,
    defineCustomElement: defineStarIcon,
  });

export type StopIconEvents = NonNullable<unknown>;

export const StopIcon: StencilReactComponent<StopIconElement, StopIconEvents> =
  /*@__PURE__*/ createComponent<StopIconElement, StopIconEvents>({
    tagName: "stop-icon",
    elementClass: StopIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as StopIconEvents,
    defineCustomElement: defineStopIcon,
  });

export type TextareaComponentEvents = {
  onNylasFormInputChanged: EventName<
    CustomEvent<{
      value: string;
      name: string;
      error: string;
      label: string;
      type: string;
    }>
  >;
};

export const TextareaComponent: StencilReactComponent<
  TextareaComponentElement,
  TextareaComponentEvents
> = /*@__PURE__*/ createComponent<
  TextareaComponentElement,
  TextareaComponentEvents
>({
  tagName: "textarea-component",
  elementClass: TextareaComponentElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormInputChanged: "nylasFormInputChanged",
  } as TextareaComponentEvents,
  defineCustomElement: defineTextareaComponent,
});

export type TimePeriodSelectorEvents = {
  onTimePeriodChanged: EventName<
    CustomEvent<{ number: number; period: string }>
  >;
};

export const TimePeriodSelector: StencilReactComponent<
  TimePeriodSelectorElement,
  TimePeriodSelectorEvents
> = /*@__PURE__*/ createComponent<
  TimePeriodSelectorElement,
  TimePeriodSelectorEvents
>({
  tagName: "time-period-selector",
  elementClass: TimePeriodSelectorElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onTimePeriodChanged: "timePeriodChanged",
  } as TimePeriodSelectorEvents,
  defineCustomElement: defineTimePeriodSelector,
});

export type ToggleSwitchEvents = {
  onNylasFormSwitchToggled: EventName<
    CustomEvent<{
      checked: boolean;
      name: string;
      label: string;
    }>
  >;
};

export const ToggleSwitch: StencilReactComponent<
  ToggleSwitchElement,
  ToggleSwitchEvents
> = /*@__PURE__*/ createComponent<ToggleSwitchElement, ToggleSwitchEvents>({
  tagName: "toggle-switch",
  elementClass: ToggleSwitchElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {
    onNylasFormSwitchToggled: "nylasFormSwitchToggled",
  } as ToggleSwitchEvents,
  defineCustomElement: defineToggleSwitch,
});

export type TooltipComponentEvents = NonNullable<unknown>;

export const TooltipComponent: StencilReactComponent<
  TooltipComponentElement,
  TooltipComponentEvents
> = /*@__PURE__*/ createComponent<
  TooltipComponentElement,
  TooltipComponentEvents
>({
  tagName: "tooltip-component",
  elementClass: TooltipComponentElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as TooltipComponentEvents,
  defineCustomElement: defineTooltipComponent,
});

export type TranslateIconEvents = NonNullable<unknown>;

export const TranslateIcon: StencilReactComponent<
  TranslateIconElement,
  TranslateIconEvents
> = /*@__PURE__*/ createComponent<TranslateIconElement, TranslateIconEvents>({
  tagName: "translate-icon",
  elementClass: TranslateIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as TranslateIconEvents,
  defineCustomElement: defineTranslateIcon,
});

export type TrashFillIconEvents = NonNullable<unknown>;

export const TrashFillIcon: StencilReactComponent<
  TrashFillIconElement,
  TrashFillIconEvents
> = /*@__PURE__*/ createComponent<TrashFillIconElement, TrashFillIconEvents>({
  tagName: "trash-fill-icon",
  elementClass: TrashFillIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as TrashFillIconEvents,
  defineCustomElement: defineTrashFillIcon,
});

export type TrashIconEvents = NonNullable<unknown>;

export const TrashIcon: StencilReactComponent<
  TrashIconElement,
  TrashIconEvents
> = /*@__PURE__*/ createComponent<TrashIconElement, TrashIconEvents>({
  tagName: "trash-icon",
  elementClass: TrashIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as TrashIconEvents,
  defineCustomElement: defineTrashIcon,
});

export type UnderlineIconEvents = NonNullable<unknown>;

export const UnderlineIcon: StencilReactComponent<
  UnderlineIconElement,
  UnderlineIconEvents
> = /*@__PURE__*/ createComponent<UnderlineIconElement, UnderlineIconEvents>({
  tagName: "underline-icon",
  elementClass: UnderlineIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as UnderlineIconEvents,
  defineCustomElement: defineUnderlineIcon,
});

export type WarningIconEvents = NonNullable<unknown>;

export const WarningIcon: StencilReactComponent<
  WarningIconElement,
  WarningIconEvents
> = /*@__PURE__*/ createComponent<WarningIconElement, WarningIconEvents>({
  tagName: "warning-icon",
  elementClass: WarningIconElement,
  // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
  react: React,
  events: {} as WarningIconEvents,
  defineCustomElement: defineWarningIcon,
});

export type ZoomIconEvents = NonNullable<unknown>;

export const ZoomIcon: StencilReactComponent<ZoomIconElement, ZoomIconEvents> =
  /*@__PURE__*/ createComponent<ZoomIconElement, ZoomIconEvents>({
    tagName: "zoom-icon",
    elementClass: ZoomIconElement,
    // @ts-ignore - ignore potential React type mismatches between the Stencil Output Target and your project.
    react: React,
    events: {} as ZoomIconEvents,
    defineCustomElement: defineZoomIcon,
  });