/* Stallion custom elements bundle */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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