/* planet custom elements bundle */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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