/* Vime custom elements bundle */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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