/* TeliaComponentLibrary custom elements bundle */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * 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';
