/* UiLibraryNext custom elements bundle */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * 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 { Components, JSX };

export * from '../types';
