/* FtbConstructor custom elements bundle */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export * from '../types';