genesys-spark-components-react 3.7.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Genesys Cloud Services, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="react" />
+import type { JSX } from 'genesys-spark-components';
+export declare const GuxAccordion: import("react").ForwardRefExoticComponent<JSX.GuxAccordion & Omit<import("react").HTMLAttributes<HTMLGuxAccordionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxAccordionElement>>;
+export declare const GuxAccordionLegacy: import("react").ForwardRefExoticComponent<JSX.GuxAccordionLegacy & Omit<import("react").HTMLAttributes<HTMLGuxAccordionLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxAccordionLegacyElement>>;
+export declare const GuxAccordionSection: import("react").ForwardRefExoticComponent<JSX.GuxAccordionSection & Omit<import("react").HTMLAttributes<HTMLGuxAccordionSectionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxAccordionSectionElement>>;
+export declare const GuxActionButton: import("react").ForwardRefExoticComponent<JSX.GuxActionButton & Omit<import("react").HTMLAttributes<HTMLGuxActionButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxActionButtonElement>>;
+export declare const GuxActionButtonLegacy: import("react").ForwardRefExoticComponent<JSX.GuxActionButtonLegacy & Omit<import("react").HTMLAttributes<HTMLGuxActionButtonLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxActionButtonLegacyElement>>;
+export declare const GuxActionItem: import("react").ForwardRefExoticComponent<JSX.GuxActionItem & Omit<import("react").HTMLAttributes<HTMLGuxActionItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxActionItemElement>>;
+export declare const GuxActionListDivider: import("react").ForwardRefExoticComponent<JSX.GuxActionListDivider & Omit<import("react").HTMLAttributes<HTMLGuxActionListDividerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxActionListDividerElement>>;
+export declare const GuxActionListLegacy: import("react").ForwardRefExoticComponent<JSX.GuxActionListLegacy & Omit<import("react").HTMLAttributes<HTMLGuxActionListLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxActionListLegacyElement>>;
+export declare const GuxActionToast: import("react").ForwardRefExoticComponent<JSX.GuxActionToast & Omit<import("react").HTMLAttributes<HTMLGuxActionToastElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxActionToastElement>>;
+export declare const GuxAdvancedDropdown: import("react").ForwardRefExoticComponent<JSX.GuxAdvancedDropdown & Omit<import("react").HTMLAttributes<HTMLGuxAdvancedDropdownElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxAdvancedDropdownElement>>;
+export declare const GuxAllRowSelect: import("react").ForwardRefExoticComponent<JSX.GuxAllRowSelect & Omit<import("react").HTMLAttributes<HTMLGuxAllRowSelectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxAllRowSelectElement>>;
+export declare const GuxBadgeBeta: import("react").ForwardRefExoticComponent<JSX.GuxBadgeBeta & Omit<import("react").HTMLAttributes<HTMLGuxBadgeBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxBadgeBetaElement>>;
+export declare const GuxBreadcrumbItem: import("react").ForwardRefExoticComponent<JSX.GuxBreadcrumbItem & Omit<import("react").HTMLAttributes<HTMLGuxBreadcrumbItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxBreadcrumbItemElement>>;
+export declare const GuxBreadcrumbs: import("react").ForwardRefExoticComponent<JSX.GuxBreadcrumbs & Omit<import("react").HTMLAttributes<HTMLGuxBreadcrumbsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxBreadcrumbsElement>>;
+export declare const GuxButton: import("react").ForwardRefExoticComponent<JSX.GuxButton & Omit<import("react").HTMLAttributes<HTMLGuxButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxButtonElement>>;
+export declare const GuxButtonMulti: import("react").ForwardRefExoticComponent<JSX.GuxButtonMulti & Omit<import("react").HTMLAttributes<HTMLGuxButtonMultiElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxButtonMultiElement>>;
+export declare const GuxButtonMultiLegacy: import("react").ForwardRefExoticComponent<JSX.GuxButtonMultiLegacy & Omit<import("react").HTMLAttributes<HTMLGuxButtonMultiLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxButtonMultiLegacyElement>>;
+export declare const GuxButtonSlotBeta: import("react").ForwardRefExoticComponent<JSX.GuxButtonSlotBeta & Omit<import("react").HTMLAttributes<HTMLGuxButtonSlotBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxButtonSlotBetaElement>>;
+export declare const GuxCalendar: import("react").ForwardRefExoticComponent<JSX.GuxCalendar & Omit<import("react").HTMLAttributes<HTMLGuxCalendarElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxCalendarElement>>;
+export declare const GuxCardBeta: import("react").ForwardRefExoticComponent<JSX.GuxCardBeta & Omit<import("react").HTMLAttributes<HTMLGuxCardBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxCardBetaElement>>;
+export declare const GuxChartColumnBeta: import("react").ForwardRefExoticComponent<JSX.GuxChartColumnBeta & Omit<import("react").HTMLAttributes<HTMLGuxChartColumnBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxChartColumnBetaElement>>;
+export declare const GuxChartDonutBeta: import("react").ForwardRefExoticComponent<JSX.GuxChartDonutBeta & Omit<import("react").HTMLAttributes<HTMLGuxChartDonutBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxChartDonutBetaElement>>;
+export declare const GuxChartLineBeta: import("react").ForwardRefExoticComponent<JSX.GuxChartLineBeta & Omit<import("react").HTMLAttributes<HTMLGuxChartLineBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxChartLineBetaElement>>;
+export declare const GuxChartPieBeta: import("react").ForwardRefExoticComponent<JSX.GuxChartPieBeta & Omit<import("react").HTMLAttributes<HTMLGuxChartPieBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxChartPieBetaElement>>;
+export declare const GuxChartScatterPlotBeta: import("react").ForwardRefExoticComponent<JSX.GuxChartScatterPlotBeta & Omit<import("react").HTMLAttributes<HTMLGuxChartScatterPlotBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxChartScatterPlotBetaElement>>;
+export declare const GuxColorSelect: import("react").ForwardRefExoticComponent<JSX.GuxColorSelect & Omit<import("react").HTMLAttributes<HTMLGuxColorSelectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxColorSelectElement>>;
+export declare const GuxCommandAction: import("react").ForwardRefExoticComponent<JSX.GuxCommandAction & Omit<import("react").HTMLAttributes<HTMLGuxCommandActionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxCommandActionElement>>;
+export declare const GuxCommandPaletteLegacy: import("react").ForwardRefExoticComponent<JSX.GuxCommandPaletteLegacy & Omit<import("react").HTMLAttributes<HTMLGuxCommandPaletteLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxCommandPaletteLegacyElement>>;
+export declare const GuxContentSearch: import("react").ForwardRefExoticComponent<JSX.GuxContentSearch & Omit<import("react").HTMLAttributes<HTMLGuxContentSearchElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxContentSearchElement>>;
+export declare const GuxCopyToClipboardBeta: import("react").ForwardRefExoticComponent<JSX.GuxCopyToClipboardBeta & Omit<import("react").HTMLAttributes<HTMLGuxCopyToClipboardBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxCopyToClipboardBetaElement>>;
+export declare const GuxDatepicker: import("react").ForwardRefExoticComponent<JSX.GuxDatepicker & Omit<import("react").HTMLAttributes<HTMLGuxDatepickerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDatepickerElement>>;
+export declare const GuxDisclosureButton: import("react").ForwardRefExoticComponent<JSX.GuxDisclosureButton & Omit<import("react").HTMLAttributes<HTMLGuxDisclosureButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDisclosureButtonElement>>;
+export declare const GuxDismissButton: import("react").ForwardRefExoticComponent<JSX.GuxDismissButton & Omit<import("react").HTMLAttributes<HTMLGuxDismissButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDismissButtonElement>>;
+export declare const GuxDropdown: import("react").ForwardRefExoticComponent<JSX.GuxDropdown & Omit<import("react").HTMLAttributes<HTMLGuxDropdownElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDropdownElement>>;
+export declare const GuxDropdownLegacy: import("react").ForwardRefExoticComponent<JSX.GuxDropdownLegacy & Omit<import("react").HTMLAttributes<HTMLGuxDropdownLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDropdownLegacyElement>>;
+export declare const GuxDropdownMultiBeta: import("react").ForwardRefExoticComponent<JSX.GuxDropdownMultiBeta & Omit<import("react").HTMLAttributes<HTMLGuxDropdownMultiBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDropdownMultiBetaElement>>;
+export declare const GuxDropdownMultiTag: import("react").ForwardRefExoticComponent<JSX.GuxDropdownMultiTag & Omit<import("react").HTMLAttributes<HTMLGuxDropdownMultiTagElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDropdownMultiTagElement>>;
+export declare const GuxDropdownOption: import("react").ForwardRefExoticComponent<JSX.GuxDropdownOption & Omit<import("react").HTMLAttributes<HTMLGuxDropdownOptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxDropdownOptionElement>>;
+export declare const GuxErrorMessageBeta: import("react").ForwardRefExoticComponent<JSX.GuxErrorMessageBeta & Omit<import("react").HTMLAttributes<HTMLGuxErrorMessageBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxErrorMessageBetaElement>>;
+export declare const GuxFlyoutMenuBeta: import("react").ForwardRefExoticComponent<JSX.GuxFlyoutMenuBeta & Omit<import("react").HTMLAttributes<HTMLGuxFlyoutMenuBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFlyoutMenuBetaElement>>;
+export declare const GuxFormFieldCheckbox: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldCheckbox & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldCheckboxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldCheckboxElement>>;
+export declare const GuxFormFieldColor: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldColor & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldColorElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldColorElement>>;
+export declare const GuxFormFieldDropdown: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldDropdown & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldDropdownElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldDropdownElement>>;
+export declare const GuxFormFieldInputClearButton: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldInputClearButton & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldInputClearButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldInputClearButtonElement>>;
+export declare const GuxFormFieldLegacy: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldLegacy & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldLegacyElement>>;
+export declare const GuxFormFieldNumber: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldNumber & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldNumberElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldNumberElement>>;
+export declare const GuxFormFieldRadio: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldRadio & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldRadioElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldRadioElement>>;
+export declare const GuxFormFieldRange: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldRange & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldRangeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldRangeElement>>;
+export declare const GuxFormFieldSearch: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldSearch & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldSearchElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldSearchElement>>;
+export declare const GuxFormFieldSelect: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldSelect & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldSelectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldSelectElement>>;
+export declare const GuxFormFieldTextLike: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldTextLike & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldTextLikeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldTextLikeElement>>;
+export declare const GuxFormFieldTextarea: import("react").ForwardRefExoticComponent<JSX.GuxFormFieldTextarea & Omit<import("react").HTMLAttributes<HTMLGuxFormFieldTextareaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxFormFieldTextareaElement>>;
+export declare const GuxIcon: import("react").ForwardRefExoticComponent<JSX.GuxIcon & Omit<import("react").HTMLAttributes<HTMLGuxIconElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxIconElement>>;
+export declare const GuxInputCheckbox: import("react").ForwardRefExoticComponent<JSX.GuxInputCheckbox & Omit<import("react").HTMLAttributes<HTMLGuxInputCheckboxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputCheckboxElement>>;
+export declare const GuxInputColor: import("react").ForwardRefExoticComponent<JSX.GuxInputColor & Omit<import("react").HTMLAttributes<HTMLGuxInputColorElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputColorElement>>;
+export declare const GuxInputColorOption: import("react").ForwardRefExoticComponent<JSX.GuxInputColorOption & Omit<import("react").HTMLAttributes<HTMLGuxInputColorOptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputColorOptionElement>>;
+export declare const GuxInputNumber: import("react").ForwardRefExoticComponent<JSX.GuxInputNumber & Omit<import("react").HTMLAttributes<HTMLGuxInputNumberElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputNumberElement>>;
+export declare const GuxInputRadio: import("react").ForwardRefExoticComponent<JSX.GuxInputRadio & Omit<import("react").HTMLAttributes<HTMLGuxInputRadioElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputRadioElement>>;
+export declare const GuxInputRange: import("react").ForwardRefExoticComponent<JSX.GuxInputRange & Omit<import("react").HTMLAttributes<HTMLGuxInputRangeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputRangeElement>>;
+export declare const GuxInputSearch: import("react").ForwardRefExoticComponent<JSX.GuxInputSearch & Omit<import("react").HTMLAttributes<HTMLGuxInputSearchElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputSearchElement>>;
+export declare const GuxInputSelect: import("react").ForwardRefExoticComponent<JSX.GuxInputSelect & Omit<import("react").HTMLAttributes<HTMLGuxInputSelectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputSelectElement>>;
+export declare const GuxInputTextLike: import("react").ForwardRefExoticComponent<JSX.GuxInputTextLike & Omit<import("react").HTMLAttributes<HTMLGuxInputTextLikeElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputTextLikeElement>>;
+export declare const GuxInputTextarea: import("react").ForwardRefExoticComponent<JSX.GuxInputTextarea & Omit<import("react").HTMLAttributes<HTMLGuxInputTextareaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxInputTextareaElement>>;
+export declare const GuxList: import("react").ForwardRefExoticComponent<JSX.GuxList & Omit<import("react").HTMLAttributes<HTMLGuxListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListElement>>;
+export declare const GuxListDivider: import("react").ForwardRefExoticComponent<JSX.GuxListDivider & Omit<import("react").HTMLAttributes<HTMLGuxListDividerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListDividerElement>>;
+export declare const GuxListDividerLegacy: import("react").ForwardRefExoticComponent<JSX.GuxListDividerLegacy & Omit<import("react").HTMLAttributes<HTMLGuxListDividerLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListDividerLegacyElement>>;
+export declare const GuxListItem: import("react").ForwardRefExoticComponent<JSX.GuxListItem & Omit<import("react").HTMLAttributes<HTMLGuxListItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListItemElement>>;
+export declare const GuxListItemLegacy: import("react").ForwardRefExoticComponent<JSX.GuxListItemLegacy & Omit<import("react").HTMLAttributes<HTMLGuxListItemLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListItemLegacyElement>>;
+export declare const GuxListLegacy: import("react").ForwardRefExoticComponent<JSX.GuxListLegacy & Omit<import("react").HTMLAttributes<HTMLGuxListLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListLegacyElement>>;
+export declare const GuxListbox: import("react").ForwardRefExoticComponent<JSX.GuxListbox & Omit<import("react").HTMLAttributes<HTMLGuxListboxElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListboxElement>>;
+export declare const GuxListboxMulti: import("react").ForwardRefExoticComponent<JSX.GuxListboxMulti & Omit<import("react").HTMLAttributes<HTMLGuxListboxMultiElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxListboxMultiElement>>;
+export declare const GuxMenu: import("react").ForwardRefExoticComponent<JSX.GuxMenu & Omit<import("react").HTMLAttributes<HTMLGuxMenuElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxMenuElement>>;
+export declare const GuxMenuOption: import("react").ForwardRefExoticComponent<JSX.GuxMenuOption & Omit<import("react").HTMLAttributes<HTMLGuxMenuOptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxMenuOptionElement>>;
+export declare const GuxModal: import("react").ForwardRefExoticComponent<JSX.GuxModal & Omit<import("react").HTMLAttributes<HTMLGuxModalElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxModalElement>>;
+export declare const GuxNotificationToast: import("react").ForwardRefExoticComponent<JSX.GuxNotificationToast & Omit<import("react").HTMLAttributes<HTMLGuxNotificationToastElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxNotificationToastElement>>;
+export declare const GuxOption: import("react").ForwardRefExoticComponent<JSX.GuxOption & Omit<import("react").HTMLAttributes<HTMLGuxOptionElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxOptionElement>>;
+export declare const GuxOptionLegacy: import("react").ForwardRefExoticComponent<JSX.GuxOptionLegacy & Omit<import("react").HTMLAttributes<HTMLGuxOptionLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxOptionLegacyElement>>;
+export declare const GuxOptionMulti: import("react").ForwardRefExoticComponent<JSX.GuxOptionMulti & Omit<import("react").HTMLAttributes<HTMLGuxOptionMultiElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxOptionMultiElement>>;
+export declare const GuxPageLoadingSpinner: import("react").ForwardRefExoticComponent<JSX.GuxPageLoadingSpinner & Omit<import("react").HTMLAttributes<HTMLGuxPageLoadingSpinnerElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPageLoadingSpinnerElement>>;
+export declare const GuxPagination: import("react").ForwardRefExoticComponent<JSX.GuxPagination & Omit<import("react").HTMLAttributes<HTMLGuxPaginationElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationElement>>;
+export declare const GuxPaginationBeta: import("react").ForwardRefExoticComponent<JSX.GuxPaginationBeta & Omit<import("react").HTMLAttributes<HTMLGuxPaginationBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationBetaElement>>;
+export declare const GuxPaginationButtons: import("react").ForwardRefExoticComponent<JSX.GuxPaginationButtons & Omit<import("react").HTMLAttributes<HTMLGuxPaginationButtonsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationButtonsElement>>;
+export declare const GuxPaginationButtonsBeta: import("react").ForwardRefExoticComponent<JSX.GuxPaginationButtonsBeta & Omit<import("react").HTMLAttributes<HTMLGuxPaginationButtonsBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationButtonsBetaElement>>;
+export declare const GuxPaginationCursor: import("react").ForwardRefExoticComponent<JSX.GuxPaginationCursor & Omit<import("react").HTMLAttributes<HTMLGuxPaginationCursorElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationCursorElement>>;
+export declare const GuxPaginationItemCounts: import("react").ForwardRefExoticComponent<JSX.GuxPaginationItemCounts & Omit<import("react").HTMLAttributes<HTMLGuxPaginationItemCountsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationItemCountsElement>>;
+export declare const GuxPaginationItemCountsBeta: import("react").ForwardRefExoticComponent<JSX.GuxPaginationItemCountsBeta & Omit<import("react").HTMLAttributes<HTMLGuxPaginationItemCountsBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationItemCountsBetaElement>>;
+export declare const GuxPaginationItemsPerPage: import("react").ForwardRefExoticComponent<JSX.GuxPaginationItemsPerPage & Omit<import("react").HTMLAttributes<HTMLGuxPaginationItemsPerPageElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationItemsPerPageElement>>;
+export declare const GuxPaginationItemsPerPageBeta: import("react").ForwardRefExoticComponent<JSX.GuxPaginationItemsPerPageBeta & Omit<import("react").HTMLAttributes<HTMLGuxPaginationItemsPerPageBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPaginationItemsPerPageBetaElement>>;
+export declare const GuxPanelFrameLegacy: import("react").ForwardRefExoticComponent<JSX.GuxPanelFrameLegacy & Omit<import("react").HTMLAttributes<HTMLGuxPanelFrameLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPanelFrameLegacyElement>>;
+export declare const GuxPopover: import("react").ForwardRefExoticComponent<JSX.GuxPopover & Omit<import("react").HTMLAttributes<HTMLGuxPopoverElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPopoverElement>>;
+export declare const GuxPopoverList: import("react").ForwardRefExoticComponent<JSX.GuxPopoverList & Omit<import("react").HTMLAttributes<HTMLGuxPopoverListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPopoverListElement>>;
+export declare const GuxPopup: import("react").ForwardRefExoticComponent<JSX.GuxPopup & Omit<import("react").HTMLAttributes<HTMLGuxPopupElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxPopupElement>>;
+export declare const GuxRadialLoading: import("react").ForwardRefExoticComponent<JSX.GuxRadialLoading & Omit<import("react").HTMLAttributes<HTMLGuxRadialLoadingElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxRadialLoadingElement>>;
+export declare const GuxRadialProgress: import("react").ForwardRefExoticComponent<JSX.GuxRadialProgress & Omit<import("react").HTMLAttributes<HTMLGuxRadialProgressElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxRadialProgressElement>>;
+export declare const GuxRating: import("react").ForwardRefExoticComponent<JSX.GuxRating & Omit<import("react").HTMLAttributes<HTMLGuxRatingElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxRatingElement>>;
+export declare const GuxRowSelect: import("react").ForwardRefExoticComponent<JSX.GuxRowSelect & Omit<import("react").HTMLAttributes<HTMLGuxRowSelectElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxRowSelectElement>>;
+export declare const GuxSidePanelButton: import("react").ForwardRefExoticComponent<JSX.GuxSidePanelButton & Omit<import("react").HTMLAttributes<HTMLGuxSidePanelButtonElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxSidePanelButtonElement>>;
+export declare const GuxSidePanelLegacy: import("react").ForwardRefExoticComponent<JSX.GuxSidePanelLegacy & Omit<import("react").HTMLAttributes<HTMLGuxSidePanelLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxSidePanelLegacyElement>>;
+export declare const GuxSimpleToast: import("react").ForwardRefExoticComponent<JSX.GuxSimpleToast & Omit<import("react").HTMLAttributes<HTMLGuxSimpleToastElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxSimpleToastElement>>;
+export declare const GuxSortControl: import("react").ForwardRefExoticComponent<JSX.GuxSortControl & Omit<import("react").HTMLAttributes<HTMLGuxSortControlElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxSortControlElement>>;
+export declare const GuxSubmenu: import("react").ForwardRefExoticComponent<JSX.GuxSubmenu & Omit<import("react").HTMLAttributes<HTMLGuxSubmenuElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxSubmenuElement>>;
+export declare const GuxSwitch: import("react").ForwardRefExoticComponent<JSX.GuxSwitch & Omit<import("react").HTMLAttributes<HTMLGuxSwitchElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxSwitchElement>>;
+export declare const GuxSwitchItem: import("react").ForwardRefExoticComponent<JSX.GuxSwitchItem & Omit<import("react").HTMLAttributes<HTMLGuxSwitchItemElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxSwitchItemElement>>;
+export declare const GuxTab: import("react").ForwardRefExoticComponent<JSX.GuxTab & Omit<import("react").HTMLAttributes<HTMLGuxTabElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabElement>>;
+export declare const GuxTabAdvanced: import("react").ForwardRefExoticComponent<JSX.GuxTabAdvanced & Omit<import("react").HTMLAttributes<HTMLGuxTabAdvancedElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabAdvancedElement>>;
+export declare const GuxTabAdvancedList: import("react").ForwardRefExoticComponent<JSX.GuxTabAdvancedList & Omit<import("react").HTMLAttributes<HTMLGuxTabAdvancedListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabAdvancedListElement>>;
+export declare const GuxTabAdvancedPanel: import("react").ForwardRefExoticComponent<JSX.GuxTabAdvancedPanel & Omit<import("react").HTMLAttributes<HTMLGuxTabAdvancedPanelElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabAdvancedPanelElement>>;
+export declare const GuxTabDropdownOptionLegacy: import("react").ForwardRefExoticComponent<JSX.GuxTabDropdownOptionLegacy & Omit<import("react").HTMLAttributes<HTMLGuxTabDropdownOptionLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabDropdownOptionLegacyElement>>;
+export declare const GuxTabLegacy: import("react").ForwardRefExoticComponent<JSX.GuxTabLegacy & Omit<import("react").HTMLAttributes<HTMLGuxTabLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabLegacyElement>>;
+export declare const GuxTabList: import("react").ForwardRefExoticComponent<JSX.GuxTabList & Omit<import("react").HTMLAttributes<HTMLGuxTabListElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabListElement>>;
+export declare const GuxTabPanel: import("react").ForwardRefExoticComponent<JSX.GuxTabPanel & Omit<import("react").HTMLAttributes<HTMLGuxTabPanelElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabPanelElement>>;
+export declare const GuxTableBeta: import("react").ForwardRefExoticComponent<JSX.GuxTableBeta & Omit<import("react").HTMLAttributes<HTMLGuxTableBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTableBetaElement>>;
+export declare const GuxTabs: import("react").ForwardRefExoticComponent<JSX.GuxTabs & Omit<import("react").HTMLAttributes<HTMLGuxTabsElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabsElement>>;
+export declare const GuxTabsAdvanced: import("react").ForwardRefExoticComponent<JSX.GuxTabsAdvanced & Omit<import("react").HTMLAttributes<HTMLGuxTabsAdvancedElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabsAdvancedElement>>;
+export declare const GuxTabsLegacy: import("react").ForwardRefExoticComponent<JSX.GuxTabsLegacy & Omit<import("react").HTMLAttributes<HTMLGuxTabsLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTabsLegacyElement>>;
+export declare const GuxTagBeta: import("react").ForwardRefExoticComponent<JSX.GuxTagBeta & Omit<import("react").HTMLAttributes<HTMLGuxTagBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTagBetaElement>>;
+export declare const GuxTextHighlight: import("react").ForwardRefExoticComponent<JSX.GuxTextHighlight & Omit<import("react").HTMLAttributes<HTMLGuxTextHighlightElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTextHighlightElement>>;
+export declare const GuxTextLabelLegacy: import("react").ForwardRefExoticComponent<JSX.GuxTextLabelLegacy & Omit<import("react").HTMLAttributes<HTMLGuxTextLabelLegacyElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTextLabelLegacyElement>>;
+export declare const GuxTimePickerBeta: import("react").ForwardRefExoticComponent<JSX.GuxTimePickerBeta & Omit<import("react").HTMLAttributes<HTMLGuxTimePickerBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTimePickerBetaElement>>;
+export declare const GuxToggle: import("react").ForwardRefExoticComponent<JSX.GuxToggle & Omit<import("react").HTMLAttributes<HTMLGuxToggleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxToggleElement>>;
+export declare const GuxToggleSlider: import("react").ForwardRefExoticComponent<JSX.GuxToggleSlider & Omit<import("react").HTMLAttributes<HTMLGuxToggleSliderElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxToggleSliderElement>>;
+export declare const GuxTooltip: import("react").ForwardRefExoticComponent<JSX.GuxTooltip & Omit<import("react").HTMLAttributes<HTMLGuxTooltipElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTooltipElement>>;
+export declare const GuxTooltipTitle: import("react").ForwardRefExoticComponent<JSX.GuxTooltipTitle & Omit<import("react").HTMLAttributes<HTMLGuxTooltipTitleElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxTooltipTitleElement>>;
+export declare const GuxVisualizationBeta: import("react").ForwardRefExoticComponent<JSX.GuxVisualizationBeta & Omit<import("react").HTMLAttributes<HTMLGuxVisualizationBetaElement>, "style"> & import("./react-component-lib/interfaces").StyleReactProps & import("react").RefAttributes<HTMLGuxVisualizationBetaElement>>;

package/dist/index.js

@@ -0,0 +1,128 @@
+/* eslint-disable */
+/* tslint:disable */
+/* auto-generated react proxies */
+import { createReactComponent } from './react-component-lib';
+export const GuxAccordion = /*@__PURE__*/ createReactComponent('gux-accordion');
+export const GuxAccordionLegacy = /*@__PURE__*/ createReactComponent('gux-accordion-legacy');
+export const GuxAccordionSection = /*@__PURE__*/ createReactComponent('gux-accordion-section');
+export const GuxActionButton = /*@__PURE__*/ createReactComponent('gux-action-button');
+export const GuxActionButtonLegacy = /*@__PURE__*/ createReactComponent('gux-action-button-legacy');
+export const GuxActionItem = /*@__PURE__*/ createReactComponent('gux-action-item');
+export const GuxActionListDivider = /*@__PURE__*/ createReactComponent('gux-action-list-divider');
+export const GuxActionListLegacy = /*@__PURE__*/ createReactComponent('gux-action-list-legacy');
+export const GuxActionToast = /*@__PURE__*/ createReactComponent('gux-action-toast');
+export const GuxAdvancedDropdown = /*@__PURE__*/ createReactComponent('gux-advanced-dropdown');
+export const GuxAllRowSelect = /*@__PURE__*/ createReactComponent('gux-all-row-select');
+export const GuxBadgeBeta = /*@__PURE__*/ createReactComponent('gux-badge-beta');
+export const GuxBreadcrumbItem = /*@__PURE__*/ createReactComponent('gux-breadcrumb-item');
+export const GuxBreadcrumbs = /*@__PURE__*/ createReactComponent('gux-breadcrumbs');
+export const GuxButton = /*@__PURE__*/ createReactComponent('gux-button');
+export const GuxButtonMulti = /*@__PURE__*/ createReactComponent('gux-button-multi');
+export const GuxButtonMultiLegacy = /*@__PURE__*/ createReactComponent('gux-button-multi-legacy');
+export const GuxButtonSlotBeta = /*@__PURE__*/ createReactComponent('gux-button-slot-beta');
+export const GuxCalendar = /*@__PURE__*/ createReactComponent('gux-calendar');
+export const GuxCardBeta = /*@__PURE__*/ createReactComponent('gux-card-beta');
+export const GuxChartColumnBeta = /*@__PURE__*/ createReactComponent('gux-chart-column-beta');
+export const GuxChartDonutBeta = /*@__PURE__*/ createReactComponent('gux-chart-donut-beta');
+export const GuxChartLineBeta = /*@__PURE__*/ createReactComponent('gux-chart-line-beta');
+export const GuxChartPieBeta = /*@__PURE__*/ createReactComponent('gux-chart-pie-beta');
+export const GuxChartScatterPlotBeta = /*@__PURE__*/ createReactComponent('gux-chart-scatter-plot-beta');
+export const GuxColorSelect = /*@__PURE__*/ createReactComponent('gux-color-select');
+export const GuxCommandAction = /*@__PURE__*/ createReactComponent('gux-command-action');
+export const GuxCommandPaletteLegacy = /*@__PURE__*/ createReactComponent('gux-command-palette-legacy');
+export const GuxContentSearch = /*@__PURE__*/ createReactComponent('gux-content-search');
+export const GuxCopyToClipboardBeta = /*@__PURE__*/ createReactComponent('gux-copy-to-clipboard-beta');
+export const GuxDatepicker = /*@__PURE__*/ createReactComponent('gux-datepicker');
+export const GuxDisclosureButton = /*@__PURE__*/ createReactComponent('gux-disclosure-button');
+export const GuxDismissButton = /*@__PURE__*/ createReactComponent('gux-dismiss-button');
+export const GuxDropdown = /*@__PURE__*/ createReactComponent('gux-dropdown');
+export const GuxDropdownLegacy = /*@__PURE__*/ createReactComponent('gux-dropdown-legacy');
+export const GuxDropdownMultiBeta = /*@__PURE__*/ createReactComponent('gux-dropdown-multi-beta');
+export const GuxDropdownMultiTag = /*@__PURE__*/ createReactComponent('gux-dropdown-multi-tag');
+export const GuxDropdownOption = /*@__PURE__*/ createReactComponent('gux-dropdown-option');
+export const GuxErrorMessageBeta = /*@__PURE__*/ createReactComponent('gux-error-message-beta');
+export const GuxFlyoutMenuBeta = /*@__PURE__*/ createReactComponent('gux-flyout-menu-beta');
+export const GuxFormFieldCheckbox = /*@__PURE__*/ createReactComponent('gux-form-field-checkbox');
+export const GuxFormFieldColor = /*@__PURE__*/ createReactComponent('gux-form-field-color');
+export const GuxFormFieldDropdown = /*@__PURE__*/ createReactComponent('gux-form-field-dropdown');
+export const GuxFormFieldInputClearButton = /*@__PURE__*/ createReactComponent('gux-form-field-input-clear-button');
+export const GuxFormFieldLegacy = /*@__PURE__*/ createReactComponent('gux-form-field-legacy');
+export const GuxFormFieldNumber = /*@__PURE__*/ createReactComponent('gux-form-field-number');
+export const GuxFormFieldRadio = /*@__PURE__*/ createReactComponent('gux-form-field-radio');
+export const GuxFormFieldRange = /*@__PURE__*/ createReactComponent('gux-form-field-range');
+export const GuxFormFieldSearch = /*@__PURE__*/ createReactComponent('gux-form-field-search');
+export const GuxFormFieldSelect = /*@__PURE__*/ createReactComponent('gux-form-field-select');
+export const GuxFormFieldTextLike = /*@__PURE__*/ createReactComponent('gux-form-field-text-like');
+export const GuxFormFieldTextarea = /*@__PURE__*/ createReactComponent('gux-form-field-textarea');
+export const GuxIcon = /*@__PURE__*/ createReactComponent('gux-icon');
+export const GuxInputCheckbox = /*@__PURE__*/ createReactComponent('gux-input-checkbox');
+export const GuxInputColor = /*@__PURE__*/ createReactComponent('gux-input-color');
+export const GuxInputColorOption = /*@__PURE__*/ createReactComponent('gux-input-color-option');
+export const GuxInputNumber = /*@__PURE__*/ createReactComponent('gux-input-number');
+export const GuxInputRadio = /*@__PURE__*/ createReactComponent('gux-input-radio');
+export const GuxInputRange = /*@__PURE__*/ createReactComponent('gux-input-range');
+export const GuxInputSearch = /*@__PURE__*/ createReactComponent('gux-input-search');
+export const GuxInputSelect = /*@__PURE__*/ createReactComponent('gux-input-select');
+export const GuxInputTextLike = /*@__PURE__*/ createReactComponent('gux-input-text-like');
+export const GuxInputTextarea = /*@__PURE__*/ createReactComponent('gux-input-textarea');
+export const GuxList = /*@__PURE__*/ createReactComponent('gux-list');
+export const GuxListDivider = /*@__PURE__*/ createReactComponent('gux-list-divider');
+export const GuxListDividerLegacy = /*@__PURE__*/ createReactComponent('gux-list-divider-legacy');
+export const GuxListItem = /*@__PURE__*/ createReactComponent('gux-list-item');
+export const GuxListItemLegacy = /*@__PURE__*/ createReactComponent('gux-list-item-legacy');
+export const GuxListLegacy = /*@__PURE__*/ createReactComponent('gux-list-legacy');
+export const GuxListbox = /*@__PURE__*/ createReactComponent('gux-listbox');
+export const GuxListboxMulti = /*@__PURE__*/ createReactComponent('gux-listbox-multi');
+export const GuxMenu = /*@__PURE__*/ createReactComponent('gux-menu');
+export const GuxMenuOption = /*@__PURE__*/ createReactComponent('gux-menu-option');
+export const GuxModal = /*@__PURE__*/ createReactComponent('gux-modal');
+export const GuxNotificationToast = /*@__PURE__*/ createReactComponent('gux-notification-toast');
+export const GuxOption = /*@__PURE__*/ createReactComponent('gux-option');
+export const GuxOptionLegacy = /*@__PURE__*/ createReactComponent('gux-option-legacy');
+export const GuxOptionMulti = /*@__PURE__*/ createReactComponent('gux-option-multi');
+export const GuxPageLoadingSpinner = /*@__PURE__*/ createReactComponent('gux-page-loading-spinner');
+export const GuxPagination = /*@__PURE__*/ createReactComponent('gux-pagination');
+export const GuxPaginationBeta = /*@__PURE__*/ createReactComponent('gux-pagination-beta');
+export const GuxPaginationButtons = /*@__PURE__*/ createReactComponent('gux-pagination-buttons');
+export const GuxPaginationButtonsBeta = /*@__PURE__*/ createReactComponent('gux-pagination-buttons-beta');
+export const GuxPaginationCursor = /*@__PURE__*/ createReactComponent('gux-pagination-cursor');
+export const GuxPaginationItemCounts = /*@__PURE__*/ createReactComponent('gux-pagination-item-counts');
+export const GuxPaginationItemCountsBeta = /*@__PURE__*/ createReactComponent('gux-pagination-item-counts-beta');
+export const GuxPaginationItemsPerPage = /*@__PURE__*/ createReactComponent('gux-pagination-items-per-page');
+export const GuxPaginationItemsPerPageBeta = /*@__PURE__*/ createReactComponent('gux-pagination-items-per-page-beta');
+export const GuxPanelFrameLegacy = /*@__PURE__*/ createReactComponent('gux-panel-frame-legacy');
+export const GuxPopover = /*@__PURE__*/ createReactComponent('gux-popover');
+export const GuxPopoverList = /*@__PURE__*/ createReactComponent('gux-popover-list');
+export const GuxPopup = /*@__PURE__*/ createReactComponent('gux-popup');
+export const GuxRadialLoading = /*@__PURE__*/ createReactComponent('gux-radial-loading');
+export const GuxRadialProgress = /*@__PURE__*/ createReactComponent('gux-radial-progress');
+export const GuxRating = /*@__PURE__*/ createReactComponent('gux-rating');
+export const GuxRowSelect = /*@__PURE__*/ createReactComponent('gux-row-select');
+export const GuxSidePanelButton = /*@__PURE__*/ createReactComponent('gux-side-panel-button');
+export const GuxSidePanelLegacy = /*@__PURE__*/ createReactComponent('gux-side-panel-legacy');
+export const GuxSimpleToast = /*@__PURE__*/ createReactComponent('gux-simple-toast');
+export const GuxSortControl = /*@__PURE__*/ createReactComponent('gux-sort-control');
+export const GuxSubmenu = /*@__PURE__*/ createReactComponent('gux-submenu');
+export const GuxSwitch = /*@__PURE__*/ createReactComponent('gux-switch');
+export const GuxSwitchItem = /*@__PURE__*/ createReactComponent('gux-switch-item');
+export const GuxTab = /*@__PURE__*/ createReactComponent('gux-tab');
+export const GuxTabAdvanced = /*@__PURE__*/ createReactComponent('gux-tab-advanced');
+export const GuxTabAdvancedList = /*@__PURE__*/ createReactComponent('gux-tab-advanced-list');
+export const GuxTabAdvancedPanel = /*@__PURE__*/ createReactComponent('gux-tab-advanced-panel');
+export const GuxTabDropdownOptionLegacy = /*@__PURE__*/ createReactComponent('gux-tab-dropdown-option-legacy');
+export const GuxTabLegacy = /*@__PURE__*/ createReactComponent('gux-tab-legacy');
+export const GuxTabList = /*@__PURE__*/ createReactComponent('gux-tab-list');
+export const GuxTabPanel = /*@__PURE__*/ createReactComponent('gux-tab-panel');
+export const GuxTableBeta = /*@__PURE__*/ createReactComponent('gux-table-beta');
+export const GuxTabs = /*@__PURE__*/ createReactComponent('gux-tabs');
+export const GuxTabsAdvanced = /*@__PURE__*/ createReactComponent('gux-tabs-advanced');
+export const GuxTabsLegacy = /*@__PURE__*/ createReactComponent('gux-tabs-legacy');
+export const GuxTagBeta = /*@__PURE__*/ createReactComponent('gux-tag-beta');
+export const GuxTextHighlight = /*@__PURE__*/ createReactComponent('gux-text-highlight');
+export const GuxTextLabelLegacy = /*@__PURE__*/ createReactComponent('gux-text-label-legacy');
+export const GuxTimePickerBeta = /*@__PURE__*/ createReactComponent('gux-time-picker-beta');
+export const GuxToggle = /*@__PURE__*/ createReactComponent('gux-toggle');
+export const GuxToggleSlider = /*@__PURE__*/ createReactComponent('gux-toggle-slider');
+export const GuxTooltip = /*@__PURE__*/ createReactComponent('gux-tooltip');
+export const GuxTooltipTitle = /*@__PURE__*/ createReactComponent('gux-tooltip-title');
+export const GuxVisualizationBeta = /*@__PURE__*/ createReactComponent('gux-visualization-beta');

package/dist/react-component-lib/createComponent.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface HTMLStencilElement extends HTMLElement {
+    componentOnReady(): Promise<this>;
+}
+interface StencilReactInternalProps<ElementType> extends React.HTMLAttributes<ElementType> {
+    forwardedRef: React.RefObject<ElementType>;
+    ref?: React.Ref<any>;
+}
+export declare const createReactComponent: <PropType, ElementType extends HTMLStencilElement, ContextStateType = {}, ExpandedPropsTypes = {}>(tagName: string, ReactComponentContext?: React.Context<ContextStateType>, manipulatePropsFunction?: (originalProps: StencilReactInternalProps<ElementType>, propsToPass: any) => ExpandedPropsTypes, defineCustomElement?: () => void) => React.ForwardRefExoticComponent<React.PropsWithoutRef<PropType & Omit<React.HTMLAttributes<ElementType>, "style"> & import("./interfaces").StyleReactProps> & React.RefAttributes<ElementType>>;
+export {};

package/dist/react-component-lib/createComponent.js

@@ -0,0 +1,74 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { createElement } from 'react';
+import { attachProps, camelToDashCase, createForwardRef, dashToPascalCase, isCoveredByReact, mergeRefs, } from './utils';
+export const createReactComponent = (tagName, ReactComponentContext, manipulatePropsFunction, defineCustomElement) => {
+    if (defineCustomElement !== undefined) {
+        defineCustomElement();
+    }
+    const displayName = dashToPascalCase(tagName);
+    const ReactComponent = class extends React.Component {
+        constructor(props) {
+            super(props);
+            this.setComponentElRef = (element) => {
+                this.componentEl = element;
+            };
+        }
+        componentDidMount() {
+            this.componentDidUpdate(this.props);
+        }
+        componentDidUpdate(prevProps) {
+            attachProps(this.componentEl, this.props, prevProps);
+        }
+        render() {
+            const _a = this.props, { children, forwardedRef, style, className, ref } = _a, cProps = __rest(_a, ["children", "forwardedRef", "style", "className", "ref"]);
+            let propsToPass = Object.keys(cProps).reduce((acc, name) => {
+                const value = cProps[name];
+                if (name.indexOf('on') === 0 && name[2] === name[2].toUpperCase()) {
+                    const eventName = name.substring(2).toLowerCase();
+                    if (typeof document !== 'undefined' && isCoveredByReact(eventName)) {
+                        acc[name] = value;
+                    }
+                }
+                else {
+                    // we should only render strings, booleans, and numbers as attrs in html.
+                    // objects, functions, arrays etc get synced via properties on mount.
+                    const type = typeof value;
+                    if (type === 'string' || type === 'boolean' || type === 'number') {
+                        acc[camelToDashCase(name)] = value;
+                    }
+                }
+                return acc;
+            }, {});
+            if (manipulatePropsFunction) {
+                propsToPass = manipulatePropsFunction(this.props, propsToPass);
+            }
+            const newProps = Object.assign(Object.assign({}, propsToPass), { ref: mergeRefs(forwardedRef, this.setComponentElRef), style });
+            /**
+             * We use createElement here instead of
+             * React.createElement to work around a
+             * bug in Vite (https://github.com/vitejs/vite/issues/6104).
+             * React.createElement causes all elements to be rendered
+             * as <tagname> instead of the actual Web Component.
+             */
+            return createElement(tagName, newProps, children);
+        }
+        static get displayName() {
+            return displayName;
+        }
+    };
+    // If context was passed to createReactComponent then conditionally add it to the Component Class
+    if (ReactComponentContext) {
+        ReactComponent.contextType = ReactComponentContext;
+    }
+    return createForwardRef(ReactComponent, displayName);
+};

package/dist/react-component-lib/createOverlayComponent.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { OverlayEventDetail } from './interfaces';
+import { StencilReactForwardedRef } from './utils';
+interface OverlayElement extends HTMLElement {
+    present: () => Promise<void>;
+    dismiss: (data?: any, role?: string | undefined) => Promise<boolean>;
+}
+export interface ReactOverlayProps {
+    children?: React.ReactNode;
+    isOpen: boolean;
+    onDidDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onDidPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillDismiss?: (event: CustomEvent<OverlayEventDetail>) => void;
+    onWillPresent?: (event: CustomEvent<OverlayEventDetail>) => void;
+}
+export declare const createOverlayComponent: <OverlayComponent extends object, OverlayType extends OverlayElement>(tagName: string, controller: {
+    create: (options: any) => Promise<OverlayType>;
+}, customElement?: any) => React.ForwardRefExoticComponent<React.PropsWithoutRef<OverlayComponent & ReactOverlayProps & {
+    forwardedRef?: StencilReactForwardedRef<OverlayType>;
+}> & React.RefAttributes<OverlayType>>;
+export {};

package/dist/react-component-lib/createOverlayComponent.js

@@ -0,0 +1,95 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { attachProps, dashToPascalCase, defineCustomElement, setRef, } from './utils';
+export const createOverlayComponent = (tagName, controller, customElement) => {
+    defineCustomElement(tagName, customElement);
+    const displayName = dashToPascalCase(tagName);
+    const didDismissEventName = `on${displayName}DidDismiss`;
+    const didPresentEventName = `on${displayName}DidPresent`;
+    const willDismissEventName = `on${displayName}WillDismiss`;
+    const willPresentEventName = `on${displayName}WillPresent`;
+    let isDismissing = false;
+    class Overlay extends React.Component {
+        constructor(props) {
+            super(props);
+            if (typeof document !== 'undefined') {
+                this.el = document.createElement('div');
+            }
+            this.handleDismiss = this.handleDismiss.bind(this);
+        }
+        static get displayName() {
+            return displayName;
+        }
+        componentDidMount() {
+            if (this.props.isOpen) {
+                this.present();
+            }
+        }
+        componentWillUnmount() {
+            if (this.overlay) {
+                this.overlay.dismiss();
+            }
+        }
+        handleDismiss(event) {
+            if (this.props.onDidDismiss) {
+                this.props.onDidDismiss(event);
+            }
+            setRef(this.props.forwardedRef, null);
+        }
+        shouldComponentUpdate(nextProps) {
+            // Check if the overlay component is about to dismiss
+            if (this.overlay && nextProps.isOpen !== this.props.isOpen && nextProps.isOpen === false) {
+                isDismissing = true;
+            }
+            return true;
+        }
+        async componentDidUpdate(prevProps) {
+            if (this.overlay) {
+                attachProps(this.overlay, this.props, prevProps);
+            }
+            if (prevProps.isOpen !== this.props.isOpen && this.props.isOpen === true) {
+                this.present(prevProps);
+            }
+            if (this.overlay && prevProps.isOpen !== this.props.isOpen && this.props.isOpen === false) {
+                await this.overlay.dismiss();
+                isDismissing = false;
+                /**
+                 * Now that the overlay is dismissed
+                 * we need to render again so that any
+                 * inner components will be unmounted
+                 */
+                this.forceUpdate();
+            }
+        }
+        async present(prevProps) {
+            const _a = this.props, { children, isOpen, onDidDismiss, onDidPresent, onWillDismiss, onWillPresent } = _a, cProps = __rest(_a, ["children", "isOpen", "onDidDismiss", "onDidPresent", "onWillDismiss", "onWillPresent"]);
+            const elementProps = Object.assign(Object.assign({}, cProps), { ref: this.props.forwardedRef, [didDismissEventName]: this.handleDismiss, [didPresentEventName]: (e) => this.props.onDidPresent && this.props.onDidPresent(e), [willDismissEventName]: (e) => this.props.onWillDismiss && this.props.onWillDismiss(e), [willPresentEventName]: (e) => this.props.onWillPresent && this.props.onWillPresent(e) });
+            this.overlay = await controller.create(Object.assign(Object.assign({}, elementProps), { component: this.el, componentProps: {} }));
+            setRef(this.props.forwardedRef, this.overlay);
+            attachProps(this.overlay, elementProps, prevProps);
+            await this.overlay.present();
+        }
+        render() {
+            /**
+             * Continue to render the component even when
+             * overlay is dismissing otherwise component
+             * will be hidden before animation is done.
+             */
+            return ReactDOM.createPortal(this.props.isOpen || isDismissing ? this.props.children : null, this.el);
+        }
+    }
+    return React.forwardRef((props, ref) => {
+        return React.createElement(Overlay, Object.assign({}, props, { forwardedRef: ref }));
+    });
+};

package/dist/react-component-lib/index.d.ts

@@ -0,0 +1,2 @@
+export { createReactComponent } from './createComponent';
+export { createOverlayComponent } from './createOverlayComponent';

package/dist/react-component-lib/index.js

@@ -0,0 +1,2 @@
+export { createReactComponent } from './createComponent';
+export { createOverlayComponent } from './createOverlayComponent';

package/dist/react-component-lib/interfaces.d.ts

@@ -0,0 +1,29 @@
+export interface EventEmitter<T = any> {
+    emit: (data?: T) => CustomEvent<T>;
+}
+export interface StyleReactProps {
+    class?: string;
+    className?: string;
+    style?: {
+        [key: string]: any;
+    };
+}
+export interface OverlayEventDetail<T = any> {
+    data?: T;
+    role?: string;
+}
+export interface OverlayInterface {
+    el: HTMLElement;
+    animated: boolean;
+    keyboardClose: boolean;
+    overlayIndex: number;
+    presented: boolean;
+    enterAnimation?: any;
+    leaveAnimation?: any;
+    didPresent: EventEmitter<void>;
+    willPresent: EventEmitter<void>;
+    willDismiss: EventEmitter<OverlayEventDetail>;
+    didDismiss: EventEmitter<OverlayEventDetail>;
+    present(): Promise<void>;
+    dismiss(data?: any, role?: string): Promise<boolean>;
+}

package/dist/react-component-lib/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/react-component-lib/utils/attachProps.d.ts

@@ -0,0 +1,12 @@
+export declare const attachProps: (node: HTMLElement, newProps: any, oldProps?: any) => void;
+export declare const getClassName: (classList: DOMTokenList, newProps: any, oldProps: any) => string;
+/**
+ * Checks if an event is supported in the current execution environment.
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+export declare const isCoveredByReact: (eventNameSuffix: string) => boolean;
+export declare const syncEvent: (node: Element & {
+    __events?: {
+        [key: string]: (e: Event) => any;
+    };
+}, eventName: string, newEventHandler?: (e: Event) => any) => void;

package/dist/react-component-lib/utils/attachProps.js

@@ -0,0 +1,97 @@
+import { camelToDashCase } from './case';
+export const attachProps = (node, newProps, oldProps = {}) => {
+    // some test frameworks don't render DOM elements, so we test here to make sure we are dealing with DOM first
+    if (node instanceof Element) {
+        // add any classes in className to the class list
+        const className = getClassName(node.classList, newProps, oldProps);
+        if (className !== '') {
+            node.className = className;
+        }
+        Object.keys(newProps).forEach((name) => {
+            if (name === 'children' ||
+                name === 'style' ||
+                name === 'ref' ||
+                name === 'class' ||
+                name === 'className' ||
+                name === 'forwardedRef') {
+                return;
+            }
+            if (name.indexOf('on') === 0 && name[2] === name[2].toUpperCase()) {
+                const eventName = name.substring(2);
+                const eventNameLc = eventName[0].toLowerCase() + eventName.substring(1);
+                if (!isCoveredByReact(eventNameLc)) {
+                    syncEvent(node, eventNameLc, newProps[name]);
+                }
+            }
+            else {
+                node[name] = newProps[name];
+                const propType = typeof newProps[name];
+                if (propType === 'string') {
+                    node.setAttribute(camelToDashCase(name), newProps[name]);
+                }
+            }
+        });
+    }
+};
+export const getClassName = (classList, newProps, oldProps) => {
+    const newClassProp = newProps.className || newProps.class;
+    const oldClassProp = oldProps.className || oldProps.class;
+    // map the classes to Maps for performance
+    const currentClasses = arrayToMap(classList);
+    const incomingPropClasses = arrayToMap(newClassProp ? newClassProp.split(' ') : []);
+    const oldPropClasses = arrayToMap(oldClassProp ? oldClassProp.split(' ') : []);
+    const finalClassNames = [];
+    // loop through each of the current classes on the component
+    // to see if it should be a part of the classNames added
+    currentClasses.forEach((currentClass) => {
+        if (incomingPropClasses.has(currentClass)) {
+            // add it as its already included in classnames coming in from newProps
+            finalClassNames.push(currentClass);
+            incomingPropClasses.delete(currentClass);
+        }
+        else if (!oldPropClasses.has(currentClass)) {
+            // add it as it has NOT been removed by user
+            finalClassNames.push(currentClass);
+        }
+    });
+    incomingPropClasses.forEach((s) => finalClassNames.push(s));
+    return finalClassNames.join(' ');
+};
+/**
+ * Checks if an event is supported in the current execution environment.
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+export const isCoveredByReact = (eventNameSuffix) => {
+    if (typeof document === 'undefined') {
+        return true;
+    }
+    else {
+        const eventName = 'on' + eventNameSuffix;
+        let isSupported = eventName in document;
+        if (!isSupported) {
+            const element = document.createElement('div');
+            element.setAttribute(eventName, 'return;');
+            isSupported = typeof element[eventName] === 'function';
+        }
+        return isSupported;
+    }
+};
+export const syncEvent = (node, eventName, newEventHandler) => {
+    const eventStore = node.__events || (node.__events = {});
+    const oldEventHandler = eventStore[eventName];
+    // Remove old listener so they don't double up.
+    if (oldEventHandler) {
+        node.removeEventListener(eventName, oldEventHandler);
+    }
+    // Bind new listener.
+    node.addEventListener(eventName, (eventStore[eventName] = function handler(e) {
+        if (newEventHandler) {
+            newEventHandler.call(this, e);
+        }
+    }));
+};
+const arrayToMap = (arr) => {
+    const map = new Map();
+    arr.forEach((s) => map.set(s, s));
+    return map;
+};

package/dist/react-component-lib/utils/case.d.ts

@@ -0,0 +1,2 @@
+export declare const dashToPascalCase: (str: string) => string;
+export declare const camelToDashCase: (str: string) => string;

package/dist/react-component-lib/utils/case.js

@@ -0,0 +1,6 @@
+export const dashToPascalCase = (str) => str
+    .toLowerCase()
+    .split('-')
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join('');
+export const camelToDashCase = (str) => str.replace(/([A-Z])/g, (m) => `-${m[0].toLowerCase()}`);

package/dist/react-component-lib/utils/dev.d.ts

@@ -0,0 +1,2 @@
+export declare const isDevMode: () => boolean;
+export declare const deprecationWarning: (key: string, message: string) => void;

package/dist/react-component-lib/utils/dev.js

@@ -0,0 +1,12 @@
+export const isDevMode = () => {
+    return process && process.env && process.env.NODE_ENV === 'development';
+};
+const warnings = {};
+export const deprecationWarning = (key, message) => {
+    if (isDevMode()) {
+        if (!warnings[key]) {
+            console.warn(message);
+            warnings[key] = true;
+        }
+    }
+};

package/dist/react-component-lib/utils/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { StyleReactProps } from '../interfaces';
+export declare type StencilReactExternalProps<PropType, ElementType> = PropType & Omit<React.HTMLAttributes<ElementType>, 'style'> & StyleReactProps;
+export declare type StencilReactForwardedRef<T> = ((instance: T | null) => void) | React.MutableRefObject<T | null> | null;
+export declare const setRef: (ref: StencilReactForwardedRef<any> | React.Ref<any> | undefined, value: any) => void;
+export declare const mergeRefs: (...refs: (StencilReactForwardedRef<any> | React.Ref<any> | undefined)[]) => React.RefCallback<any>;
+export declare const createForwardRef: <PropType, ElementType>(ReactComponent: any, displayName: string) => React.ForwardRefExoticComponent<React.PropsWithoutRef<PropType & Omit<React.HTMLAttributes<ElementType>, "style"> & StyleReactProps> & React.RefAttributes<ElementType>>;
+export declare const defineCustomElement: (tagName: string, customElement: any) => void;
+export * from './attachProps';
+export * from './case';

package/dist/react-component-lib/utils/index.js

@@ -0,0 +1,33 @@
+import React from 'react';
+export const setRef = (ref, value) => {
+    if (typeof ref === 'function') {
+        ref(value);
+    }
+    else if (ref != null) {
+        // Cast as a MutableRef so we can assign current
+        ref.current = value;
+    }
+};
+export const mergeRefs = (...refs) => {
+    return (value) => {
+        refs.forEach(ref => {
+            setRef(ref, value);
+        });
+    };
+};
+export const createForwardRef = (ReactComponent, displayName) => {
+    const forwardRef = (props, ref) => {
+        return React.createElement(ReactComponent, Object.assign({}, props, { forwardedRef: ref }));
+    };
+    forwardRef.displayName = displayName;
+    return React.forwardRef(forwardRef);
+};
+export const defineCustomElement = (tagName, customElement) => {
+    if (customElement !== undefined &&
+        typeof customElements !== 'undefined' &&
+        !customElements.get(tagName)) {
+        customElements.define(tagName, customElement);
+    }
+};
+export * from './attachProps';
+export * from './case';

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "genesys-spark-components-react",
+  "version": "3.7.2",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -r ./dist || true",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@types/react": "^17.0.37",
+    "@types/react-dom": "^17.0.11"
+  },
+  "devDependencies": {
+    "react": "^17.0.2",
+    "react-dom": "17.0.2",
+    "typescript": "^4.5.4"
+  },
+  "peerDependencies": {
+    "genesys-spark-components": "3",
+    "react": "16 - 17",
+    "react-dom": "16 - 17"
+  }
+}