jtBaseApp/node_modules/@esri/calcite-components/dist/custom-elements/index.d.ts

/* calcite custom elements bundle */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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