/* GritWebcomponents custom elements bundle */

import type { Components, JSX } from "../types/components";

interface AccordionDemo extends Components.AccordionDemo, HTMLElement {}
export const AccordionDemo: {
  prototype: AccordionDemo;
  new (): AccordionDemo;
};

interface AnalyticsScroll extends Components.AnalyticsScroll, HTMLElement {}
export const AnalyticsScroll: {
  prototype: AnalyticsScroll;
  new (): AnalyticsScroll;
};

interface AutocompleteDemo extends Components.AutocompleteDemo, HTMLElement {}
export const AutocompleteDemo: {
  prototype: AutocompleteDemo;
  new (): AutocompleteDemo;
};

interface BadgesDemo extends Components.BadgesDemo, HTMLElement {}
export const BadgesDemo: {
  prototype: BadgesDemo;
  new (): BadgesDemo;
};

interface ButtonsDemo extends Components.ButtonsDemo, HTMLElement {}
export const ButtonsDemo: {
  prototype: ButtonsDemo;
  new (): ButtonsDemo;
};

interface CardsDemo extends Components.CardsDemo, HTMLElement {}
export const CardsDemo: {
  prototype: CardsDemo;
  new (): CardsDemo;
};

interface CheckboxDemo extends Components.CheckboxDemo, HTMLElement {}
export const CheckboxDemo: {
  prototype: CheckboxDemo;
  new (): CheckboxDemo;
};

interface ChipsDemo extends Components.ChipsDemo, HTMLElement {}
export const ChipsDemo: {
  prototype: ChipsDemo;
  new (): ChipsDemo;
};

interface ClipboardCardDemo extends Components.ClipboardCardDemo, HTMLElement {}
export const ClipboardCardDemo: {
  prototype: ClipboardCardDemo;
  new (): ClipboardCardDemo;
};

interface DebitCreditField extends Components.DebitCreditField, HTMLElement {}
export const DebitCreditField: {
  prototype: DebitCreditField;
  new (): DebitCreditField;
};

interface DemoStepper extends Components.DemoStepper, HTMLElement {}
export const DemoStepper: {
  prototype: DemoStepper;
  new (): DemoStepper;
};

interface FieldDemo extends Components.FieldDemo, HTMLElement {}
export const FieldDemo: {
  prototype: FieldDemo;
  new (): FieldDemo;
};

interface FormsDemo extends Components.FormsDemo, HTMLElement {}
export const FormsDemo: {
  prototype: FormsDemo;
  new (): FormsDemo;
};

interface GritWcAccordion extends Components.GritWcAccordion, HTMLElement {}
export const GritWcAccordion: {
  prototype: GritWcAccordion;
  new (): GritWcAccordion;
};

interface GritWcAccordionGroup extends Components.GritWcAccordionGroup, HTMLElement {}
export const GritWcAccordionGroup: {
  prototype: GritWcAccordionGroup;
  new (): GritWcAccordionGroup;
};

interface GritWcAnalytics extends Components.GritWcAnalytics, HTMLElement {}
export const GritWcAnalytics: {
  prototype: GritWcAnalytics;
  new (): GritWcAnalytics;
};

interface GritWcAutocomplete extends Components.GritWcAutocomplete, HTMLElement {}
export const GritWcAutocomplete: {
  prototype: GritWcAutocomplete;
  new (): GritWcAutocomplete;
};

interface GritWcAutocompleteItem extends Components.GritWcAutocompleteItem, HTMLElement {}
export const GritWcAutocompleteItem: {
  prototype: GritWcAutocompleteItem;
  new (): GritWcAutocompleteItem;
};

interface GritWcBadge extends Components.GritWcBadge, HTMLElement {}
export const GritWcBadge: {
  prototype: GritWcBadge;
  new (): GritWcBadge;
};

interface GritWcButton extends Components.GritWcButton, HTMLElement {}
export const GritWcButton: {
  prototype: GritWcButton;
  new (): GritWcButton;
};

interface GritWcCard extends Components.GritWcCard, HTMLElement {}
export const GritWcCard: {
  prototype: GritWcCard;
  new (): GritWcCard;
};

interface GritWcCheckbox extends Components.GritWcCheckbox, HTMLElement {}
export const GritWcCheckbox: {
  prototype: GritWcCheckbox;
  new (): GritWcCheckbox;
};

interface GritWcCheckboxGroup extends Components.GritWcCheckboxGroup, HTMLElement {}
export const GritWcCheckboxGroup: {
  prototype: GritWcCheckboxGroup;
  new (): GritWcCheckboxGroup;
};

interface GritWcChip extends Components.GritWcChip, HTMLElement {}
export const GritWcChip: {
  prototype: GritWcChip;
  new (): GritWcChip;
};

interface GritWcClipboardCard extends Components.GritWcClipboardCard, HTMLElement {}
export const GritWcClipboardCard: {
  prototype: GritWcClipboardCard;
  new (): GritWcClipboardCard;
};

interface GritWcField extends Components.GritWcField, HTMLElement {}
export const GritWcField: {
  prototype: GritWcField;
  new (): GritWcField;
};

interface GritWcFieldIcon extends Components.GritWcFieldIcon, HTMLElement {}
export const GritWcFieldIcon: {
  prototype: GritWcFieldIcon;
  new (): GritWcFieldIcon;
};

interface GritWcIcon extends Components.GritWcIcon, HTMLElement {}
export const GritWcIcon: {
  prototype: GritWcIcon;
  new (): GritWcIcon;
};

interface GritWcIconButton extends Components.GritWcIconButton, HTMLElement {}
export const GritWcIconButton: {
  prototype: GritWcIconButton;
  new (): GritWcIconButton;
};

interface GritWcInPageNavigation extends Components.GritWcInPageNavigation, HTMLElement {}
export const GritWcInPageNavigation: {
  prototype: GritWcInPageNavigation;
  new (): GritWcInPageNavigation;
};

interface GritWcLinearLoader extends Components.GritWcLinearLoader, HTMLElement {}
export const GritWcLinearLoader: {
  prototype: GritWcLinearLoader;
  new (): GritWcLinearLoader;
};

interface GritWcListSelect extends Components.GritWcListSelect, HTMLElement {}
export const GritWcListSelect: {
  prototype: GritWcListSelect;
  new (): GritWcListSelect;
};

interface GritWcListSelectItem extends Components.GritWcListSelectItem, HTMLElement {}
export const GritWcListSelectItem: {
  prototype: GritWcListSelectItem;
  new (): GritWcListSelectItem;
};

interface GritWcLoaderMessage extends Components.GritWcLoaderMessage, HTMLElement {}
export const GritWcLoaderMessage: {
  prototype: GritWcLoaderMessage;
  new (): GritWcLoaderMessage;
};

interface GritWcMessage extends Components.GritWcMessage, HTMLElement {}
export const GritWcMessage: {
  prototype: GritWcMessage;
  new (): GritWcMessage;
};

interface GritWcMessageGroup extends Components.GritWcMessageGroup, HTMLElement {}
export const GritWcMessageGroup: {
  prototype: GritWcMessageGroup;
  new (): GritWcMessageGroup;
};

interface GritWcMoireCard extends Components.GritWcMoireCard, HTMLElement {}
export const GritWcMoireCard: {
  prototype: GritWcMoireCard;
  new (): GritWcMoireCard;
};

interface GritWcNotification extends Components.GritWcNotification, HTMLElement {}
export const GritWcNotification: {
  prototype: GritWcNotification;
  new (): GritWcNotification;
};

interface GritWcNotificationAction extends Components.GritWcNotificationAction, HTMLElement {}
export const GritWcNotificationAction: {
  prototype: GritWcNotificationAction;
  new (): GritWcNotificationAction;
};

interface GritWcNotificationFlag extends Components.GritWcNotificationFlag, HTMLElement {}
export const GritWcNotificationFlag: {
  prototype: GritWcNotificationFlag;
  new (): GritWcNotificationFlag;
};

interface GritWcOptionSelect extends Components.GritWcOptionSelect, HTMLElement {}
export const GritWcOptionSelect: {
  prototype: GritWcOptionSelect;
  new (): GritWcOptionSelect;
};

interface GritWcOptionSelectElement extends Components.GritWcOptionSelectElement, HTMLElement {}
export const GritWcOptionSelectElement: {
  prototype: GritWcOptionSelectElement;
  new (): GritWcOptionSelectElement;
};

interface GritWcOverlayContainer extends Components.GritWcOverlayContainer, HTMLElement {}
export const GritWcOverlayContainer: {
  prototype: GritWcOverlayContainer;
  new (): GritWcOverlayContainer;
};

interface GritWcProgLogo extends Components.GritWcProgLogo, HTMLElement {}
export const GritWcProgLogo: {
  prototype: GritWcProgLogo;
  new (): GritWcProgLogo;
};

interface GritWcQrCode extends Components.GritWcQrCode, HTMLElement {}
export const GritWcQrCode: {
  prototype: GritWcQrCode;
  new (): GritWcQrCode;
};

interface GritWcRadio extends Components.GritWcRadio, HTMLElement {}
export const GritWcRadio: {
  prototype: GritWcRadio;
  new (): GritWcRadio;
};

interface GritWcRadioGroup extends Components.GritWcRadioGroup, HTMLElement {}
export const GritWcRadioGroup: {
  prototype: GritWcRadioGroup;
  new (): GritWcRadioGroup;
};

interface GritWcSkeletonItem extends Components.GritWcSkeletonItem, HTMLElement {}
export const GritWcSkeletonItem: {
  prototype: GritWcSkeletonItem;
  new (): GritWcSkeletonItem;
};

interface GritWcSkiplink extends Components.GritWcSkiplink, HTMLElement {}
export const GritWcSkiplink: {
  prototype: GritWcSkiplink;
  new (): GritWcSkiplink;
};

interface GritWcSlider extends Components.GritWcSlider, HTMLElement {}
export const GritWcSlider: {
  prototype: GritWcSlider;
  new (): GritWcSlider;
};

interface GritWcSpinner extends Components.GritWcSpinner, HTMLElement {}
export const GritWcSpinner: {
  prototype: GritWcSpinner;
  new (): GritWcSpinner;
};

interface GritWcStep extends Components.GritWcStep, HTMLElement {}
export const GritWcStep: {
  prototype: GritWcStep;
  new (): GritWcStep;
};

interface GritWcStepper extends Components.GritWcStepper, HTMLElement {}
export const GritWcStepper: {
  prototype: GritWcStepper;
  new (): GritWcStepper;
};

interface GritWcSwitch extends Components.GritWcSwitch, HTMLElement {}
export const GritWcSwitch: {
  prototype: GritWcSwitch;
  new (): GritWcSwitch;
};

interface GritWcTopNavBar extends Components.GritWcTopNavBar, HTMLElement {}
export const GritWcTopNavBar: {
  prototype: GritWcTopNavBar;
  new (): GritWcTopNavBar;
};

interface GritWcValidationMessageItem extends Components.GritWcValidationMessageItem, HTMLElement {}
export const GritWcValidationMessageItem: {
  prototype: GritWcValidationMessageItem;
  new (): GritWcValidationMessageItem;
};

interface GritWcValidationMessageList extends Components.GritWcValidationMessageList, HTMLElement {}
export const GritWcValidationMessageList: {
  prototype: GritWcValidationMessageList;
  new (): GritWcValidationMessageList;
};

interface IconButtonDemo extends Components.IconButtonDemo, HTMLElement {}
export const IconButtonDemo: {
  prototype: IconButtonDemo;
  new (): IconButtonDemo;
};

interface IconsDemo extends Components.IconsDemo, HTMLElement {}
export const IconsDemo: {
  prototype: IconsDemo;
  new (): IconsDemo;
};

interface LinearLoaderDemo extends Components.LinearLoaderDemo, HTMLElement {}
export const LinearLoaderDemo: {
  prototype: LinearLoaderDemo;
  new (): LinearLoaderDemo;
};

interface ListSelectDemo extends Components.ListSelectDemo, HTMLElement {}
export const ListSelectDemo: {
  prototype: ListSelectDemo;
  new (): ListSelectDemo;
};

interface LogoDemo extends Components.LogoDemo, HTMLElement {}
export const LogoDemo: {
  prototype: LogoDemo;
  new (): LogoDemo;
};

interface MobileEmailField extends Components.MobileEmailField, HTMLElement {}
export const MobileEmailField: {
  prototype: MobileEmailField;
  new (): MobileEmailField;
};

interface MoireCardDemo extends Components.MoireCardDemo, HTMLElement {}
export const MoireCardDemo: {
  prototype: MoireCardDemo;
  new (): MoireCardDemo;
};

interface NotificationsDemo extends Components.NotificationsDemo, HTMLElement {}
export const NotificationsDemo: {
  prototype: NotificationsDemo;
  new (): NotificationsDemo;
};

interface OtpCodeField extends Components.OtpCodeField, HTMLElement {}
export const OtpCodeField: {
  prototype: OtpCodeField;
  new (): OtpCodeField;
};

interface OverlayContainerDemo extends Components.OverlayContainerDemo, HTMLElement {}
export const OverlayContainerDemo: {
  prototype: OverlayContainerDemo;
  new (): OverlayContainerDemo;
};

interface QrCodeDemo extends Components.QrCodeDemo, HTMLElement {}
export const QrCodeDemo: {
  prototype: QrCodeDemo;
  new (): QrCodeDemo;
};

interface RadioSelectDemo extends Components.RadioSelectDemo, HTMLElement {}
export const RadioSelectDemo: {
  prototype: RadioSelectDemo;
  new (): RadioSelectDemo;
};

interface RadiosDemo extends Components.RadiosDemo, HTMLElement {}
export const RadiosDemo: {
  prototype: RadiosDemo;
  new (): RadiosDemo;
};

interface RouterIndex extends Components.RouterIndex, HTMLElement {}
export const RouterIndex: {
  prototype: RouterIndex;
  new (): RouterIndex;
};

interface SkeletonDemo extends Components.SkeletonDemo, HTMLElement {}
export const SkeletonDemo: {
  prototype: SkeletonDemo;
  new (): SkeletonDemo;
};

interface SliderDemo extends Components.SliderDemo, HTMLElement {}
export const SliderDemo: {
  prototype: SliderDemo;
  new (): SliderDemo;
};

interface SpinnerDemo extends Components.SpinnerDemo, HTMLElement {}
export const SpinnerDemo: {
  prototype: SpinnerDemo;
  new (): SpinnerDemo;
};

interface SwitchesDemo extends Components.SwitchesDemo, HTMLElement {}
export const SwitchesDemo: {
  prototype: SwitchesDemo;
  new (): SwitchesDemo;
};

interface TopNavBarDemo extends Components.TopNavBarDemo, HTMLElement {}
export const TopNavBarDemo: {
  prototype: TopNavBarDemo;
  new (): TopNavBarDemo;
};

interface ValidatorsDemo extends Components.ValidatorsDemo, HTMLElement {}
export const ValidatorsDemo: {
  prototype: ValidatorsDemo;
  new (): ValidatorsDemo;
};

interface VariablesDemo extends Components.VariablesDemo, HTMLElement {}
export const VariablesDemo: {
  prototype: VariablesDemo;
  new (): VariablesDemo;
};

/**
 * Utility to define all custom elements within this package using the tag name provided in the component's source. 
 * When defining each custom element, it will also check it's safe to define by:
 *
 * 1. Ensuring the "customElements" registry is available in the global context (window).
 * 2. The component tag name is not already defined.
 *
 * Use the standard [customElements.define()](https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define) 
 * method instead to define custom elements individually, or to provide a different tag name.
 */
export declare const defineCustomElements: (opts?: any) => void;

/**
 * Used to manually set the base path where assets can be found.
 * If the script is used as "module", it's recommended to use "import.meta.url",
 * such as "setAssetPath(import.meta.url)". Other options include
 * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
 * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
 * But do note that this configuration depends on how your script is bundled, or lack of
 * bunding, and where your assets can be loaded from. Additionally custom bundling
 * will have to ensure the static assets are copied to its build directory.
 */
export declare const setAssetPath: (path: string) => void;

export interface SetPlatformOptions {
  raf?: (c: FrameRequestCallback) => number;
  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
  ce?: (eventName: string, opts?: any) => CustomEvent;
}
export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;

export type { Components, JSX };

export * from '../types';