## API Report File for "@jupyter/web-components"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { Accordion as Accordion_2 } from '@microsoft/fast-foundation';
import { AccordionItem as AccordionItem_2 } from '@microsoft/fast-foundation';
import { AccordionItemOptions } from '@microsoft/fast-foundation';
import { Anchor as Anchor_2 } from '@microsoft/fast-foundation';
import { AnchoredRegion as AnchoredRegion_2 } from '@microsoft/fast-foundation';
import { AnchorOptions } from '@microsoft/fast-foundation';
import { ARIAGlobalStatesAndProperties } from '@microsoft/fast-foundation';
import { Avatar as Avatar_2 } from '@microsoft/fast-foundation';
import { AvatarOptions } from '@microsoft/fast-foundation';
import { Badge as Badge_2 } from '@microsoft/fast-foundation';
import { BaseProgress } from '@microsoft/fast-foundation';
import { Behavior } from '@microsoft/fast-element';
import { Breadcrumb as Breadcrumb_2 } from '@microsoft/fast-foundation';
import { BreadcrumbItem as BreadcrumbItem_2 } from '@microsoft/fast-foundation';
import { BreadcrumbItemOptions } from '@microsoft/fast-foundation';
import { Button as Button_2 } from '@microsoft/fast-foundation';
import { ButtonOptions } from '@microsoft/fast-foundation';
import { Card as Card_2 } from '@microsoft/fast-foundation';
import { Checkbox as Checkbox_2 } from '@microsoft/fast-foundation';
import { CheckboxOptions } from '@microsoft/fast-foundation';
import { Combobox as Combobox_2 } from '@microsoft/fast-foundation';
import { ComboboxOptions } from '@microsoft/fast-foundation';
import { Constructable } from '@microsoft/fast-element';
import type { Container } from '@microsoft/fast-foundation';
import { CSSDesignToken } from '@microsoft/fast-foundation';
import { DataGrid as DataGrid_2 } from '@microsoft/fast-foundation';
import { DataGridCell as DataGridCell_2 } from '@microsoft/fast-foundation';
import { DataGridRow as DataGridRow_2 } from '@microsoft/fast-foundation';
import { DelegatesARIATextbox } from '@microsoft/fast-foundation';
import { DesignSystem } from '@microsoft/fast-foundation';
import { DesignToken } from '@microsoft/fast-foundation';
import { Dialog as Dialog_2 } from '@microsoft/fast-foundation';
import { Direction } from '@microsoft/fast-web-utilities';
import { Disclosure as Disclosure_2 } from '@microsoft/fast-foundation';
import { Divider as Divider_2 } from '@microsoft/fast-foundation';
import { ElementDefinitionContext } from '@microsoft/fast-foundation';
import { ElementStyles } from '@microsoft/fast-element';
import { FASTElement } from '@microsoft/fast-element';
import { FormAssociated } from '@microsoft/fast-foundation';
import { FoundationElement } from '@microsoft/fast-foundation';
import { FoundationElementDefinition } from '@microsoft/fast-foundation';
import { FoundationElementRegistry } from '@microsoft/fast-foundation';
import { FoundationElementTemplate } from '@microsoft/fast-foundation';
import { ListboxElement } from '@microsoft/fast-foundation';
import { ListboxOption } from '@microsoft/fast-foundation';
import { ListboxOptionOptions } from '@microsoft/fast-foundation';
import { Menu as Menu_2 } from '@microsoft/fast-foundation';
import { MenuItem as MenuItem_2 } from '@microsoft/fast-foundation';
import { MenuItemOptions } from '@microsoft/fast-foundation';
import { NumberField as NumberField_2 } from '@microsoft/fast-foundation';
import { NumberFieldOptions } from '@microsoft/fast-foundation';
import { Orientation } from '@microsoft/fast-web-utilities';
import { OverrideFoundationElementDefinition } from '@microsoft/fast-foundation';
import { Picker as Picker_2 } from '@microsoft/fast-foundation';
import { PickerList as PickerList_2 } from '@microsoft/fast-foundation';
import { PickerListItem as PickerListItem_2 } from '@microsoft/fast-foundation';
import { PickerMenu as PickerMenu_2 } from '@microsoft/fast-foundation';
import { PickerMenuOption as PickerMenuOption_2 } from '@microsoft/fast-foundation';
import { ProgressOptions } from '@microsoft/fast-foundation';
import { ProgressRingOptions } from '@microsoft/fast-foundation';
import { Radio as Radio_2 } from '@microsoft/fast-foundation';
import { RadioGroup as RadioGroup_2 } from '@microsoft/fast-foundation';
import { RadioOptions } from '@microsoft/fast-foundation';
import { Search as Search_2 } from '@microsoft/fast-foundation';
import { SearchOptions } from '@microsoft/fast-foundation';
import { Select as Select_2 } from '@microsoft/fast-foundation';
import { SelectOptions } from '@microsoft/fast-foundation';
import { Skeleton as Skeleton_2 } from '@microsoft/fast-foundation';
import { Slider as Slider_2 } from '@microsoft/fast-foundation';
import { SliderLabel as SliderLabel_2 } from '@microsoft/fast-foundation';
import { SliderOptions } from '@microsoft/fast-foundation';
import { StartEnd } from '@microsoft/fast-foundation';
import { StartEndOptions } from '@microsoft/fast-foundation';
import { Switch as Switch_2 } from '@microsoft/fast-foundation';
import { SwitchOptions } from '@microsoft/fast-foundation';
import { Tab as Tab_2 } from '@microsoft/fast-foundation';
import { TabPanel as TabPanel_2 } from '@microsoft/fast-foundation';
import { Tabs as Tabs_2 } from '@microsoft/fast-foundation';
import { TabsOptions } from '@microsoft/fast-foundation';
import { TextArea as TextArea_2 } from '@microsoft/fast-foundation';
import { TextField as TextField_2 } from '@microsoft/fast-foundation';
import { TextFieldOptions } from '@microsoft/fast-foundation';
import { Toolbar as Toolbar_2 } from '@microsoft/fast-foundation';
import { ToolbarOptions as ToolbarOptions_2 } from '@microsoft/fast-foundation';
import { Tooltip as Tooltip_2 } from '@microsoft/fast-foundation';
import { TreeItem as TreeItem_2 } from '@microsoft/fast-foundation';
import { TreeItemOptions } from '@microsoft/fast-foundation';
import { TreeView as TreeView_2 } from '@microsoft/fast-foundation';
import { ViewTemplate } from '@microsoft/fast-element';

// @public (undocumented)
export const accentColor: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentFillActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentFillActiveDelta: DesignToken<number>;

// @public (undocumented)
export const accentFillFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentFillFocusDelta: DesignToken<number>;

// @public (undocumented)
export const accentFillHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentFillHoverDelta: DesignToken<number>;

// @public (undocumented)
export const accentFillRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const accentFillRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentFillRestDelta: DesignToken<number>;

// @public (undocumented)
export const accentForegroundActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentForegroundActiveDelta: DesignToken<number>;

// @public (undocumented)
export const accentForegroundFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentForegroundFocusDelta: DesignToken<number>;

// @public (undocumented)
export const accentForegroundHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentForegroundHoverDelta: DesignToken<number>;

// @public (undocumented)
export const accentForegroundRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const accentForegroundRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const accentForegroundRestDelta: DesignToken<number>;

// @public (undocumented)
export const accentPalette: DesignToken<Palette<Swatch>>;

// @public
export class Accordion extends Accordion_2 {
}

// @public
export class AccordionItem extends AccordionItem_2 {
}

// @public
export const accordionItemStyles: FoundationElementTemplate<ElementStyles, AccordionItemOptions>;

// @public
export const accordionStyles: FoundationElementTemplate<ElementStyles>;

// @public
export function addJupyterLabThemeChangeListener(): void;

// @public
export const allComponents: {
    jpAccordion: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Accordion_2;
    template: FoundationElementTemplate<ViewTemplate<Accordion_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Accordion_2;
    template: FoundationElementTemplate<ViewTemplate<Accordion_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Accordion>;
    jpAccordionItem: (overrideDefinition?: OverrideFoundationElementDefinition<AccordionItemOptions> | undefined) => FoundationElementRegistry<AccordionItemOptions, Constructable<FoundationElement>>;
    jpAnchor: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Anchor_2;
    template: FoundationElementTemplate<ViewTemplate<Anchor_2, any>, AnchorOptions>;
    styles: FoundationElementTemplate<ElementStyles, AnchorOptions>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Anchor_2;
    template: FoundationElementTemplate<ViewTemplate<Anchor_2, any>, AnchorOptions>;
    styles: FoundationElementTemplate<ElementStyles, AnchorOptions>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }, typeof Anchor>;
    jpAnchoredRegion: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: AnchoredRegion_2;
    template: FoundationElementTemplate<ViewTemplate<AnchoredRegion_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: AnchoredRegion_2;
    template: FoundationElementTemplate<ViewTemplate<AnchoredRegion_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof AnchoredRegion>;
    jpAvatar: (overrideDefinition?: OverrideFoundationElementDefinition<AvatarOptions> | undefined) => FoundationElementRegistry<AvatarOptions, Constructable<FoundationElement>>;
    jpBadge: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Badge_2;
    template: FoundationElementTemplate<ViewTemplate<Badge_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Badge_2;
    template: FoundationElementTemplate<ViewTemplate<Badge_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Badge>;
    jpBreadcrumb: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Breadcrumb_2;
    template: FoundationElementTemplate<ViewTemplate<Breadcrumb_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Breadcrumb_2;
    template: FoundationElementTemplate<ViewTemplate<Breadcrumb_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Breadcrumb>;
    jpBreadcrumbItem: (overrideDefinition?: OverrideFoundationElementDefinition<BreadcrumbItemOptions> | undefined) => FoundationElementRegistry<BreadcrumbItemOptions, Constructable<FoundationElement>>;
    jpButton: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, typeof Button>;
    jpCard: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Card_2;
    template: FoundationElementTemplate<ViewTemplate<Card_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Card_2;
    template: FoundationElementTemplate<ViewTemplate<Card_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Card>;
    jpCheckbox: (overrideDefinition?: OverrideFoundationElementDefinition<CheckboxOptions> | undefined) => FoundationElementRegistry<CheckboxOptions, Constructable<FoundationElement>>;
    jpCombobox: (overrideDefinition?: OverrideFoundationElementDefinition<ComboboxOptions> | undefined) => FoundationElementRegistry<ComboboxOptions, Constructable<FoundationElement>>;
    jpDataGrid: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: DataGrid_2;
    template: FoundationElementTemplate<ViewTemplate<DataGrid_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: DataGrid_2;
    template: FoundationElementTemplate<ViewTemplate<DataGrid_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof DataGrid>;
    jpDataGridCell: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: DataGridCell_2;
    template: FoundationElementTemplate<ViewTemplate<DataGridCell_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: DataGridCell_2;
    template: FoundationElementTemplate<ViewTemplate<DataGridCell_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof DataGridCell>;
    jpDataGridRow: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: DataGridRow_2;
    template: FoundationElementTemplate<ViewTemplate<DataGridRow_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: DataGridRow_2;
    template: FoundationElementTemplate<ViewTemplate<DataGridRow_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof DataGridRow>;
    jpDateField: (overrideDefinition?: OverrideFoundationElementDefinition<DateFieldOptions> | undefined) => FoundationElementRegistry<DateFieldOptions, Constructable<FoundationElement>>;
    jpDesignSystemProvider: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, typeof DesignSystemProvider>;
    jpDialog: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Dialog_2;
    template: FoundationElementTemplate<ViewTemplate<Dialog_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Dialog_2;
    template: FoundationElementTemplate<ViewTemplate<Dialog_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Dialog>;
    jpDisclosure: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Disclosure_2;
    template: FoundationElementTemplate<ViewTemplate<Disclosure_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Disclosure_2;
    template: FoundationElementTemplate<ViewTemplate<Disclosure_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Disclosure>;
    jpDivider: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Divider_2;
    template: FoundationElementTemplate<ViewTemplate<Divider_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Divider_2;
    template: FoundationElementTemplate<ViewTemplate<Divider_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Divider>;
    jpListbox: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: ListboxElement;
    template: FoundationElementTemplate<ViewTemplate<ListboxElement, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: ListboxElement;
    template: FoundationElementTemplate<ViewTemplate<ListboxElement, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Listbox>;
    jpMenu: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Menu_2;
    template: FoundationElementTemplate<ViewTemplate<Menu_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Menu_2;
    template: FoundationElementTemplate<ViewTemplate<Menu_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Menu>;
    jpMenuItem: (overrideDefinition?: OverrideFoundationElementDefinition<MenuItemOptions> | undefined) => FoundationElementRegistry<MenuItemOptions, Constructable<FoundationElement>>;
    jpNumberField: (overrideDefinition?: OverrideFoundationElementDefinition<NumberFieldOptions> | undefined) => FoundationElementRegistry<NumberFieldOptions, Constructable<FoundationElement>>;
    jpOption: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: ListboxOption;
    template: FoundationElementTemplate<ViewTemplate<ListboxOption, any>, ListboxOptionOptions>;
    styles: FoundationElementTemplate<ElementStyles, ListboxOptionOptions>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: ListboxOption;
    template: FoundationElementTemplate<ViewTemplate<ListboxOption, any>, ListboxOptionOptions>;
    styles: FoundationElementTemplate<ElementStyles, ListboxOptionOptions>;
    }, typeof Option_2>;
    jpPicker: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Picker_2;
    template: FoundationElementTemplate<ViewTemplate<Picker_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    shadowOptions: {};
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Picker_2;
    template: FoundationElementTemplate<ViewTemplate<Picker_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    shadowOptions: {};
    }, typeof Picker>;
    jpPickerList: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: PickerList_2;
    template: FoundationElementTemplate<ViewTemplate<PickerList_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: PickerList_2;
    template: FoundationElementTemplate<ViewTemplate<PickerList_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, PickerList>;
    jpPickerListItem: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: PickerListItem_2;
    template: FoundationElementTemplate<ViewTemplate<PickerListItem_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: PickerListItem_2;
    template: FoundationElementTemplate<ViewTemplate<PickerListItem_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, PickerListItem>;
    jpPickerMenu: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, Constructable<FoundationElement>>;
    jpPickerMenuOption: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: PickerMenuOption_2;
    template: FoundationElementTemplate<ViewTemplate<PickerMenuOption_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: PickerMenuOption_2;
    template: FoundationElementTemplate<ViewTemplate<PickerMenuOption_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, PickerMenuOption>;
    jpProgress: (overrideDefinition?: OverrideFoundationElementDefinition<ProgressOptions> | undefined) => FoundationElementRegistry<ProgressOptions, Constructable<FoundationElement>>;
    jpProgressRing: (overrideDefinition?: OverrideFoundationElementDefinition<ProgressRingOptions> | undefined) => FoundationElementRegistry<ProgressRingOptions, Constructable<FoundationElement>>;
    jpRadio: (overrideDefinition?: OverrideFoundationElementDefinition<RadioOptions> | undefined) => FoundationElementRegistry<RadioOptions, Constructable<FoundationElement>>;
    jpRadioGroup: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: RadioGroup_2;
    template: FoundationElementTemplate<ViewTemplate<RadioGroup_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: RadioGroup_2;
    template: FoundationElementTemplate<ViewTemplate<RadioGroup_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof RadioGroup>;
    jpSearch: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Search_2;
    template: FoundationElementTemplate<ViewTemplate<Search_2, any>, SearchOptions>;
    styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Search_2;
    template: FoundationElementTemplate<ViewTemplate<Search_2, any>, SearchOptions>;
    styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }, typeof Search>;
    jpSelect: (overrideDefinition?: OverrideFoundationElementDefinition<SelectOptions> | undefined) => FoundationElementRegistry<SelectOptions, Constructable<FoundationElement>>;
    jpSkeleton: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Skeleton_2;
    template: FoundationElementTemplate<ViewTemplate<Skeleton_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Skeleton_2;
    template: FoundationElementTemplate<ViewTemplate<Skeleton_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Skeleton>;
    jpSlider: (overrideDefinition?: OverrideFoundationElementDefinition<SliderOptions> | undefined) => FoundationElementRegistry<SliderOptions, Constructable<FoundationElement>>;
    jpSliderLabel: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: SliderLabel_2;
    template: FoundationElementTemplate<ViewTemplate<SliderLabel_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: SliderLabel_2;
    template: FoundationElementTemplate<ViewTemplate<SliderLabel_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof SliderLabel>;
    jpSwitch: (overrideDefinition?: OverrideFoundationElementDefinition<SwitchOptions> | undefined) => FoundationElementRegistry<SwitchOptions, Constructable<FoundationElement>>;
    jpTab: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Tab_2;
    template: FoundationElementTemplate<ViewTemplate<Tab_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Tab_2;
    template: FoundationElementTemplate<ViewTemplate<Tab_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof Tab>;
    jpTabPanel: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: TabPanel_2;
    template: FoundationElementTemplate<ViewTemplate<TabPanel_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: TabPanel_2;
    template: FoundationElementTemplate<ViewTemplate<TabPanel_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof TabPanel>;
    jpTabs: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: Tabs_2;
    template: FoundationElementTemplate<ViewTemplate<Tabs_2, any>, TabsOptions>;
    styles: FoundationElementTemplate<ElementStyles, TabsOptions>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: Tabs_2;
    template: FoundationElementTemplate<ViewTemplate<Tabs_2, any>, TabsOptions>;
    styles: FoundationElementTemplate<ElementStyles, TabsOptions>;
    }, typeof Tabs>;
    jpTextArea: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: TextArea_2;
    template: FoundationElementTemplate<ViewTemplate<TextArea_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: TextArea_2;
    template: FoundationElementTemplate<ViewTemplate<TextArea_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }, typeof TextArea>;
    jpTextField: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: TextField_2;
    template: FoundationElementTemplate<ViewTemplate<TextField_2, any>, TextFieldOptions>;
    styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: TextField_2;
    template: FoundationElementTemplate<ViewTemplate<TextField_2, any>, TextFieldOptions>;
    styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }, typeof TextField>;
    jpToolbar: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: FoundationToolbar;
    template: FoundationElementTemplate<ViewTemplate<Toolbar_2, any>, ToolbarOptions_2>;
    styles: FoundationElementTemplate<ElementStyles, ToolbarOptions_2>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: FoundationToolbar;
    template: FoundationElementTemplate<ViewTemplate<Toolbar_2, any>, ToolbarOptions_2>;
    styles: FoundationElementTemplate<ElementStyles, ToolbarOptions_2>;
    shadowOptions: {
    delegatesFocus: true;
    };
    }, typeof Toolbar>;
    jpTooltip: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, typeof Tooltip>;
    jpTreeItem: (overrideDefinition?: OverrideFoundationElementDefinition<TreeItemOptions> | undefined) => FoundationElementRegistry<TreeItemOptions, Constructable<FoundationElement>>;
    jpTreeView: (overrideDefinition?: OverrideFoundationElementDefinition<    {
    baseName: string;
    baseClass: TreeView_2;
    template: FoundationElementTemplate<ViewTemplate<TreeView_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }> | undefined) => FoundationElementRegistry<    {
    baseName: string;
    baseClass: TreeView_2;
    template: FoundationElementTemplate<ViewTemplate<TreeView_2, any>, FoundationElementDefinition>;
    styles: FoundationElementTemplate<ElementStyles>;
    }, typeof TreeView>;
    register(container?: Container, ...rest: any[]): void;
};

// @public
export class Anchor extends Anchor_2 {
    appearance?: AnchorAppearance;
    // (undocumented)
    appearanceChanged(oldValue: AnchorAppearance, newValue: AnchorAppearance): void;
    // (undocumented)
    connectedCallback(): void;
    // @internal
    defaultSlottedContentChanged(oldValue: any, newValue: any): void;
}

// @public
export type AnchorAppearance = ButtonAppearance | 'hypertext';

// @public
export class AnchoredRegion extends AnchoredRegion_2 {
}

// @public
export const anchoredRegionStyles: FoundationElementTemplate<ElementStyles>;

// @public
export const anchorStyles: FoundationElementTemplate<ElementStyles, AnchorOptions>;

// @public
export function applyJupyterTheme(): void;

// @public
export class Avatar extends Avatar_2 {
    alt: string | undefined;
    imgSrc: string | undefined;
}

// @public
export const avatarStyles: FoundationElementTemplate<ElementStyles, AvatarOptions>;

// @public
export class Badge extends Badge_2 {
}

// @public
export const badgeStyles: FoundationElementTemplate<ElementStyles>;

// @public (undocumented)
export const baseHeightMultiplier: CSSDesignToken<number>;

// @public (undocumented)
export const baseHorizontalSpacingMultiplier: CSSDesignToken<number>;

// @public (undocumented)
export const baseLayerLuminance: CSSDesignToken<number>;

// @public (undocumented)
export const bodyFont: CSSDesignToken<string>;

// @public
export class Breadcrumb extends Breadcrumb_2 {
}

// @public
export class BreadcrumbItem extends BreadcrumbItem_2 {
}

// @public
export const breadcrumbItemStyles: FoundationElementTemplate<ElementStyles, BreadcrumbItemOptions>;

// @public
export const breadcrumbStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class Button extends Button_2 {
    appearance: ButtonAppearance;
    defaultSlottedContentChanged(oldValue: HTMLElement[], newValue: HTMLElement[]): void;
    // @deprecated
    minimal: boolean;
    scale?: ButtonScale;
}

// @public
export type ButtonAppearance = 'accent' | 'error' | 'lightweight' | 'neutral' | 'outline' | 'stealth';

// @public
export type ButtonScale = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';

// @public
export const buttonStyles: (context: ElementDefinitionContext, definition: ButtonOptions) => ElementStyles;

// @public
export class Card extends Card_2 {
    // (undocumented)
    connectedCallback(): void;
}

// @public
export const cardStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class Checkbox extends Checkbox_2 {
    // (undocumented)
    indeterminateChanged(prev: boolean, next: boolean): void;
}

// @public
export const checkboxStyles: FoundationElementTemplate<ElementStyles, CheckboxOptions>;

// @public
export const checkboxTemplate: FoundationElementTemplate<ViewTemplate<Checkbox>, CheckboxOptions>;

// @public (undocumented)
export interface ColorRecipe {
    // (undocumented)
    evaluate(element: HTMLElement, reference?: Swatch): Swatch;
}

// @public
export class Combobox extends Combobox_2 {
    autoWidth: boolean;
    protected autoWidthChanged(prev: boolean | undefined, next: boolean): void;
    // @internal @override
    connectedCallback(): void;
    // @internal (undocumented)
    protected maxHeightChanged(prev: number | undefined, next: number): void;
    // @deprecated
    minimal: boolean;
    scale?: ComboboxScale;
    protected setAutoWidth(): void;
    // @internal
    slottedOptionsChanged(prev: Element[] | undefined, next: Element[]): void;
    // @internal
    protected updateComputedStylesheet(): void;
}

// @public
export type ComboboxScale = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';

// @public
export const comboboxStyles: FoundationElementTemplate<ElementStyles, ComboboxOptions>;

// @public (undocumented)
export const controlCornerRadius: CSSDesignToken<number>;

// @public
export class DataGrid extends DataGrid_2 {
}

// @public
export class DataGridCell extends DataGridCell_2 {
}

// @public
export const dataGridCellStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class DataGridRow extends DataGridRow_2 {
}

// @public
export const dataGridRowStyles: FoundationElementTemplate<ElementStyles>;

// @public
export const dataGridStyles: FoundationElementTemplate<ElementStyles>;

// Warning: (ae-forgotten-export) The symbol "FormAssociatedDateField" needs to be exported by the entry point index.d.ts
// Warning: (ae-internal-mixed-release-tag) Mixed release tags are not allowed for "DateField" because one of its declarations is marked as @internal
//
// @public
export class DateField extends FormAssociatedDateField {
    appearance: DateFieldAppearance;
    autofocus: boolean;
    // @internal (undocumented)
    connectedCallback(): void;
    // @internal
    control: HTMLInputElement;
    // @internal (undocumented)
    defaultSlottedNodes: Node[];
    // @internal
    handleBlur(): void;
    // @internal
    handleChange(): void;
    // @internal
    handleKeyDown(e: KeyboardEvent): boolean;
    // @internal
    handleTextInput(): void;
    list: string;
    max: Date;
    // @internal
    maxChanged(previous: Date, next: Date): void;
    min: Date;
    // @internal
    minChanged(previous: Date, next: Date): void;
    readOnly: boolean;
    step: number;
    stepDown(): void;
    stepUp(): void;
    get valueAsDate(): Date;
    set valueAsDate(next: Date);
    get valueAsNumber(): number;
    set valueAsNumber(next: number);
    // @internal
    valueChanged(previous: string, next: string): void;
}

// @internal
export interface DateField extends StartEnd, DelegatesARIATextbox {
}

// @public
export type DateFieldAppearance = 'filled' | 'outline';

// @public
export type DateFieldOptions = FoundationElementDefinition & StartEndOptions;

// @public
export const dateFieldStyles: FoundationElementTemplate<ElementStyles, DateFieldOptions>;

// @public
export const dateFieldTemplate: FoundationElementTemplate<ViewTemplate<DateField>, DateFieldOptions>;

// Warning: (ae-internal-mixed-release-tag) Mixed release tags are not allowed for "DelegatesARIAToolbar" because one of its declarations is marked as @internal
//
// @public
export class DelegatesARIAToolbar {
    ariaLabel: string | null;
    ariaLabelledby: string | null;
}

// @internal
export interface DelegatesARIAToolbar extends ARIAGlobalStatesAndProperties {
}

// @public (undocumented)
export const density: CSSDesignToken<number>;

// Warning: (ae-internal-missing-underscore) The name "DesignSystemProvider" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export class DesignSystemProvider extends FoundationElement {
    constructor();
    accentColor?: Swatch;
    accentFillActiveDelta?: number;
    accentFillFocusDelta?: number;
    accentFillHoverDelta?: number;
    accentFillRestDelta?: number;
    accentForegroundActiveDelta?: number;
    accentForegroundFocusDelta?: number;
    accentForegroundHoverDelta?: number;
    accentForegroundRestDelta?: number;
    baseHeightMultiplier?: number;
    baseHorizontalSpacingMultiplier?: number;
    baseLayerLuminance?: number;
    controlCornerRadius?: number;
    density?: number;
    designUnit?: number;
    direction?: Direction;
    disabledOpacity?: number;
    errorColor?: Swatch;
    fillColor?: Swatch;
    focusStrokeWidth?: number;
    neutralColor?: Swatch;
    neutralFillActiveDelta?: number;
    neutralFillFocusDelta?: number;
    neutralFillHoverDelta?: number;
    neutralFillInputActiveDelta?: number;
    neutralFillInputFocusDelta?: number;
    neutralFillInputHoverDelta?: number;
    neutralFillInputRestDelta?: number;
    neutralFillLayerRestDelta?: number;
    neutralFillRestDelta?: number;
    neutralFillStealthActiveDelta?: number;
    neutralFillStealthFocusDelta?: number;
    neutralFillStealthHoverDelta?: number;
    neutralFillStealthRestDelta?: number;
    neutralFillStrongActiveDelta?: number;
    neutralFillStrongFocusDelta?: number;
    neutralFillStrongHoverDelta?: number;
    neutralStrokeActiveDelta?: number;
    neutralStrokeDividerRestDelta?: number;
    neutralStrokeFocusDelta?: number;
    neutralStrokeHoverDelta?: number;
    neutralStrokeRestDelta?: number;
    noPaint: boolean;
    strokeWidth?: number;
    typeRampBaseFontSize?: string;
    typeRampBaseLineHeight?: string;
    typeRampMinus1FontSize?: string;
    typeRampMinus1LineHeight?: string;
    typeRampMinus2FontSize?: string;
    typeRampMinus2LineHeight?: string;
    typeRampPlus1FontSize?: string;
    typeRampPlus1LineHeight?: string;
    typeRampPlus2FontSize?: string;
    typeRampPlus2LineHeight?: string;
    typeRampPlus3FontSize?: string;
    typeRampPlus3LineHeight?: string;
    typeRampPlus4FontSize?: string;
    typeRampPlus4LineHeight?: string;
    typeRampPlus5FontSize?: string;
    typeRampPlus5LineHeight?: string;
    typeRampPlus6FontSize?: string;
    typeRampPlus6LineHeight?: string;
}

// @public
export const designSystemProviderStyles: (context: ElementDefinitionContext, definition: FoundationElementDefinition) => ElementStyles;

// @public
export const designSystemProviderTemplate: (context: ElementDefinitionContext, definition: FoundationElementDefinition) => ViewTemplate<any, any>;

// @public (undocumented)
export const designUnit: CSSDesignToken<number>;

// @public
export class Dialog extends Dialog_2 {
}

// @public
export const dialogStyles: FoundationElementTemplate<ElementStyles>;

// @public (undocumented)
export const direction: CSSDesignToken<Direction>;

// @public
export class DirectionalStyleSheetBehavior implements Behavior {
    constructor(ltr: ElementStyles | null, rtl: ElementStyles | null);
    // @internal (undocumented)
    bind(source: FASTElement & HTMLElement): void;
    // @internal (undocumented)
    unbind(source: FASTElement & HTMLElement): void;
}

// @public (undocumented)
export const disabledOpacity: CSSDesignToken<number>;

// @public
export class Disclosure extends Disclosure_2 {
    appearance?: DisclosureAppearance;
    // (undocumented)
    appearanceChanged(oldValue: DisclosureAppearance, newValue: DisclosureAppearance): void;
    // (undocumented)
    connectedCallback(): void;
    // (undocumented)
    get disclosureHeight(): number;
    // @override
    protected onToggle(): void;
    // @override
    protected setup(): void;
}

// @public
export type DisclosureAppearance = 'accent' | 'lightweight';

// @public
export const disclosureStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class Divider extends Divider_2 {
}

// @public
export const dividerStyles: FoundationElementTemplate<ElementStyles>;

// @public
export const elementScale: CSSDesignToken<number>;

// @public (undocumented)
export const errorColor: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorFillActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorFillFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorFillHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorFillRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const errorFillRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorForegroundActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorForegroundFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorForegroundHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const errorForegroundRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const errorForegroundRest: CSSDesignToken<Swatch>;

// @public
export const errorPalette: DesignToken<Palette<Swatch>>;

// @public (undocumented)
export const fillColor: CSSDesignToken<Swatch>;

// @public (undocumented)
export const focusStrokeInner: CSSDesignToken<Swatch>;

// @public (undocumented)
export const focusStrokeInnerRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const focusStrokeOuter: CSSDesignToken<Swatch>;

// @public (undocumented)
export const focusStrokeOuterRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const focusStrokeWidth: CSSDesignToken<number>;

// @public (undocumented)
export const foregroundOnAccentActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnAccentActiveLarge: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnAccentFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnAccentFocusLarge: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnAccentHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnAccentHoverLarge: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnAccentLargeRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const foregroundOnAccentRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const foregroundOnAccentRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnAccentRestLarge: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorActiveLarge: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorFocusLarge: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorHoverLarge: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorLargeRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const foregroundOnErrorRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const foregroundOnErrorRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const foregroundOnErrorRestLarge: CSSDesignToken<Swatch>;

// Warning: (ae-internal-mixed-release-tag) Mixed release tags are not allowed for "FoundationToolbar" because one of its declarations is marked as @internal
//
// @public
export class FoundationToolbar extends FoundationElement {
    // @internal
    get activeIndex(): number;
    set activeIndex(value: number);
    // @internal
    protected get allSlottedItems(): (HTMLElement | Node)[];
    // (undocumented)
    childItems: Element[];
    // (undocumented)
    protected childItemsChanged(prev: undefined | Element[], next: Element[]): void;
    // @internal (undocumented)
    connectedCallback(): void;
    // @internal
    direction: Direction;
    // @internal
    focusinHandler(e: FocusEvent): boolean | void;
    // @internal
    keydownHandler(e: KeyboardEvent): boolean | void;
    // @internal
    mouseDownHandler(e: MouseEvent): boolean | void;
    orientation: Orientation;
    // @internal
    protected reduceFocusableElements(): void;
    // @internal
    slottedItems: HTMLElement[];
    // (undocumented)
    protected slottedItemsChanged(): void;
    // @internal
    slottedLabel: HTMLElement[];
}

// @internal (undocumented)
export interface FoundationToolbar extends StartEnd, DelegatesARIAToolbar {
}

// @public
export const heightNumberAsToken: DesignToken<number>;

// @public
export const horizontalSliderLabelStyles: ElementStyles;

// @public
export const imgTemplate: ViewTemplate<Avatar, any>;

// @public (undocumented)
export interface InteractiveColorRecipe {
    // (undocumented)
    evaluate(element: HTMLElement, reference?: Swatch): InteractiveSwatchSet;
}

// @public (undocumented)
export interface InteractiveSwatchSet {
    active: Swatch;
    focus: Swatch;
    hover: Swatch;
    rest: Swatch;
}

// @public
export function isDark(color: Swatch): boolean;

// @public
export const jpAccordion: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Accordion_2;
template: FoundationElementTemplate<ViewTemplate<Accordion_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Accordion_2;
template: FoundationElementTemplate<ViewTemplate<Accordion_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Accordion>;

// @public
export const jpAccordionItem: (overrideDefinition?: OverrideFoundationElementDefinition<AccordionItemOptions> | undefined) => FoundationElementRegistry<AccordionItemOptions, Constructable<FoundationElement>>;

// @public
export const jpAnchor: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Anchor_2;
template: FoundationElementTemplate<ViewTemplate<Anchor_2, any>, AnchorOptions>;
styles: FoundationElementTemplate<ElementStyles, AnchorOptions>;
shadowOptions: {
delegatesFocus: true;
};
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Anchor_2;
template: FoundationElementTemplate<ViewTemplate<Anchor_2, any>, AnchorOptions>;
styles: FoundationElementTemplate<ElementStyles, AnchorOptions>;
shadowOptions: {
delegatesFocus: true;
};
}, typeof Anchor>;

// @beta
export const jpAnchoredRegion: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof AnchoredRegion_2;
template: FoundationElementTemplate<ViewTemplate<AnchoredRegion_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof AnchoredRegion_2;
template: FoundationElementTemplate<ViewTemplate<AnchoredRegion_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof AnchoredRegion>;

// @public
export const jpAvatar: (overrideDefinition?: OverrideFoundationElementDefinition<AvatarOptions> | undefined) => FoundationElementRegistry<AvatarOptions, Constructable<FoundationElement>>;

// @public
export const jpBadge: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Badge_2;
template: FoundationElementTemplate<ViewTemplate<Badge_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Badge_2;
template: FoundationElementTemplate<ViewTemplate<Badge_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Badge>;

// @public
export const jpBreadcrumb: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Breadcrumb_2;
template: FoundationElementTemplate<ViewTemplate<Breadcrumb_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Breadcrumb_2;
template: FoundationElementTemplate<ViewTemplate<Breadcrumb_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Breadcrumb>;

// @public
export const jpBreadcrumbItem: (overrideDefinition?: OverrideFoundationElementDefinition<BreadcrumbItemOptions> | undefined) => FoundationElementRegistry<BreadcrumbItemOptions, Constructable<FoundationElement>>;

// @public
export const jpButton: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, typeof Button>;

// @public
export const jpCard: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Card_2;
template: FoundationElementTemplate<ViewTemplate<Card_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Card_2;
template: FoundationElementTemplate<ViewTemplate<Card_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Card>;

// @public
export const jpCheckbox: (overrideDefinition?: OverrideFoundationElementDefinition<CheckboxOptions> | undefined) => FoundationElementRegistry<CheckboxOptions, Constructable<FoundationElement>>;

// @public
export const jpCombobox: (overrideDefinition?: OverrideFoundationElementDefinition<ComboboxOptions> | undefined) => FoundationElementRegistry<ComboboxOptions, Constructable<FoundationElement>>;

// @public
export const jpDataGrid: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof DataGrid_2;
template: FoundationElementTemplate<ViewTemplate<DataGrid_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof DataGrid_2;
template: FoundationElementTemplate<ViewTemplate<DataGrid_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof DataGrid>;

// @public
export const jpDataGridCell: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof DataGridCell_2;
template: FoundationElementTemplate<ViewTemplate<DataGridCell_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof DataGridCell_2;
template: FoundationElementTemplate<ViewTemplate<DataGridCell_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof DataGridCell>;

// @public
export const jpDataGridRow: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof DataGridRow_2;
template: FoundationElementTemplate<ViewTemplate<DataGridRow_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof DataGridRow_2;
template: FoundationElementTemplate<ViewTemplate<DataGridRow_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof DataGridRow>;

// @public
export const jpDateField: (overrideDefinition?: OverrideFoundationElementDefinition<DateFieldOptions> | undefined) => FoundationElementRegistry<DateFieldOptions, Constructable<FoundationElement>>;

// Warning: (ae-incompatible-release-tags) The symbol "jpDesignSystemProvider" is marked as @public, but its signature references "DesignSystemProvider" which is marked as @internal
//
// @public
export const jpDesignSystemProvider: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, typeof DesignSystemProvider>;

// @public
export const jpDialog: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Dialog_2;
template: FoundationElementTemplate<ViewTemplate<Dialog_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Dialog_2;
template: FoundationElementTemplate<ViewTemplate<Dialog_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Dialog>;

// @public
export const jpDisclosure: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Disclosure_2;
template: FoundationElementTemplate<ViewTemplate<Disclosure_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Disclosure_2;
template: FoundationElementTemplate<ViewTemplate<Disclosure_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Disclosure>;

// @public
export const jpDivider: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Divider_2;
template: FoundationElementTemplate<ViewTemplate<Divider_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Divider_2;
template: FoundationElementTemplate<ViewTemplate<Divider_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Divider>;

// @public
export const jpListbox: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof ListboxElement;
template: FoundationElementTemplate<ViewTemplate<ListboxElement, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof ListboxElement;
template: FoundationElementTemplate<ViewTemplate<ListboxElement, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Listbox>;

// @public
export const jpMenu: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Menu_2;
template: FoundationElementTemplate<ViewTemplate<Menu_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Menu_2;
template: FoundationElementTemplate<ViewTemplate<Menu_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Menu>;

// @public
export const jpMenuItem: (overrideDefinition?: OverrideFoundationElementDefinition<MenuItemOptions> | undefined) => FoundationElementRegistry<MenuItemOptions, Constructable<FoundationElement>>;

// @public
export const jpNumberField: (overrideDefinition?: OverrideFoundationElementDefinition<NumberFieldOptions> | undefined) => FoundationElementRegistry<NumberFieldOptions, Constructable<FoundationElement>>;

// @public
export const jpOption: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof ListboxOption;
template: FoundationElementTemplate<ViewTemplate<ListboxOption, any>, ListboxOptionOptions>;
styles: FoundationElementTemplate<ElementStyles, ListboxOptionOptions>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof ListboxOption;
template: FoundationElementTemplate<ViewTemplate<ListboxOption, any>, ListboxOptionOptions>;
styles: FoundationElementTemplate<ElementStyles, ListboxOptionOptions>;
}, typeof Option_2>;

// @alpha
export const jpPicker: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Picker_2;
template: FoundationElementTemplate<ViewTemplate<Picker_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
shadowOptions: {};
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Picker_2;
template: FoundationElementTemplate<ViewTemplate<Picker_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
shadowOptions: {};
}, typeof Picker>;

// @alpha
export const jpPickerList: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof PickerList_2;
template: FoundationElementTemplate<ViewTemplate<PickerList_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof PickerList_2;
template: FoundationElementTemplate<ViewTemplate<PickerList_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof PickerList>;

// @alpha
export const jpPickerListItem: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof PickerListItem_2;
template: FoundationElementTemplate<ViewTemplate<PickerListItem_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof PickerListItem_2;
template: FoundationElementTemplate<ViewTemplate<PickerListItem_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof PickerListItem>;

// @alpha
export const jpPickerMenu: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, Constructable<FoundationElement>>;

// @alpha
export const jpPickerMenuOption: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof PickerMenuOption_2;
template: FoundationElementTemplate<ViewTemplate<PickerMenuOption_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof PickerMenuOption_2;
template: FoundationElementTemplate<ViewTemplate<PickerMenuOption_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof PickerMenuOption>;

// @public
export const jpProgress: (overrideDefinition?: OverrideFoundationElementDefinition<ProgressOptions> | undefined) => FoundationElementRegistry<ProgressOptions, Constructable<FoundationElement>>;

// @public
export const jpProgressRing: (overrideDefinition?: OverrideFoundationElementDefinition<ProgressRingOptions> | undefined) => FoundationElementRegistry<ProgressRingOptions, Constructable<FoundationElement>>;

// @public
export const jpRadio: (overrideDefinition?: OverrideFoundationElementDefinition<RadioOptions> | undefined) => FoundationElementRegistry<RadioOptions, Constructable<FoundationElement>>;

// @public
export const jpRadioGroup: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof RadioGroup_2;
template: FoundationElementTemplate<ViewTemplate<RadioGroup_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof RadioGroup_2;
template: FoundationElementTemplate<ViewTemplate<RadioGroup_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof RadioGroup>;

// @public
export const jpSearch: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Search_2;
template: FoundationElementTemplate<ViewTemplate<Search_2, any>, SearchOptions>;
styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
shadowOptions: {
delegatesFocus: true;
};
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Search_2;
template: FoundationElementTemplate<ViewTemplate<Search_2, any>, SearchOptions>;
styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
shadowOptions: {
delegatesFocus: true;
};
}, typeof Search>;

// @public
export const jpSelect: (overrideDefinition?: OverrideFoundationElementDefinition<SelectOptions> | undefined) => FoundationElementRegistry<SelectOptions, Constructable<FoundationElement>>;

// @public
export const jpSkeleton: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Skeleton_2;
template: FoundationElementTemplate<ViewTemplate<Skeleton_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Skeleton_2;
template: FoundationElementTemplate<ViewTemplate<Skeleton_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Skeleton>;

// @public
export const jpSlider: (overrideDefinition?: OverrideFoundationElementDefinition<SliderOptions> | undefined) => FoundationElementRegistry<SliderOptions, Constructable<FoundationElement>>;

// @public
export const jpSliderLabel: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof SliderLabel_2;
template: FoundationElementTemplate<ViewTemplate<SliderLabel_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof SliderLabel_2;
template: FoundationElementTemplate<ViewTemplate<SliderLabel_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof SliderLabel>;

// @public
export const jpSwitch: (overrideDefinition?: OverrideFoundationElementDefinition<SwitchOptions> | undefined) => FoundationElementRegistry<SwitchOptions, Constructable<FoundationElement>>;

// @public
export const jpTab: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Tab_2;
template: FoundationElementTemplate<ViewTemplate<Tab_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Tab_2;
template: FoundationElementTemplate<ViewTemplate<Tab_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof Tab>;

// @public
export const jpTabPanel: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof TabPanel_2;
template: FoundationElementTemplate<ViewTemplate<TabPanel_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof TabPanel_2;
template: FoundationElementTemplate<ViewTemplate<TabPanel_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof TabPanel>;

// @public
export const jpTabs: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof Tabs_2;
template: FoundationElementTemplate<ViewTemplate<Tabs_2, any>, TabsOptions>;
styles: FoundationElementTemplate<ElementStyles, TabsOptions>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof Tabs_2;
template: FoundationElementTemplate<ViewTemplate<Tabs_2, any>, TabsOptions>;
styles: FoundationElementTemplate<ElementStyles, TabsOptions>;
}, typeof Tabs>;

// @public
export const jpTextArea: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof TextArea_2;
template: FoundationElementTemplate<ViewTemplate<TextArea_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
shadowOptions: {
delegatesFocus: true;
};
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof TextArea_2;
template: FoundationElementTemplate<ViewTemplate<TextArea_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
shadowOptions: {
delegatesFocus: true;
};
}, typeof TextArea>;

// @public
export const jpTextField: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof TextField_2;
template: FoundationElementTemplate<ViewTemplate<TextField_2, any>, TextFieldOptions>;
styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
shadowOptions: {
delegatesFocus: true;
};
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof TextField_2;
template: FoundationElementTemplate<ViewTemplate<TextField_2, any>, TextFieldOptions>;
styles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;
shadowOptions: {
delegatesFocus: true;
};
}, typeof TextField>;

// @public
export const jpToolbar: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof FoundationToolbar;
template: FoundationElementTemplate<ViewTemplate<Toolbar_2, any>, ToolbarOptions_2>;
styles: FoundationElementTemplate<ElementStyles, ToolbarOptions_2>;
shadowOptions: {
delegatesFocus: true;
};
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof FoundationToolbar;
template: FoundationElementTemplate<ViewTemplate<Toolbar_2, any>, ToolbarOptions_2>;
styles: FoundationElementTemplate<ElementStyles, ToolbarOptions_2>;
shadowOptions: {
delegatesFocus: true;
};
}, typeof Toolbar>;

// @public
export const jpTooltip: (overrideDefinition?: OverrideFoundationElementDefinition<FoundationElementDefinition> | undefined) => FoundationElementRegistry<FoundationElementDefinition, typeof Tooltip>;

// @public
export const jpTreeItem: (overrideDefinition?: OverrideFoundationElementDefinition<TreeItemOptions> | undefined) => FoundationElementRegistry<TreeItemOptions, Constructable<FoundationElement>>;

// @public
export const jpTreeView: (overrideDefinition?: OverrideFoundationElementDefinition<    {
baseName: string;
baseClass: typeof TreeView_2;
template: FoundationElementTemplate<ViewTemplate<TreeView_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}> | undefined) => FoundationElementRegistry<    {
baseName: string;
baseClass: typeof TreeView_2;
template: FoundationElementTemplate<ViewTemplate<TreeView_2, any>, FoundationElementDefinition>;
styles: FoundationElementTemplate<ElementStyles>;
}, typeof TreeView>;

// @public
export class Listbox extends ListboxElement {
    // @internal
    protected sizeChanged(prev: number | undefined, next: number): void;
    // @internal
    protected updateComputedStylesheet(): void;
}

// @public
export const listboxStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class Menu extends Menu_2 {
    // @internal (undocumented)
    connectedCallback(): void;
}

// @public
export class MenuItem extends MenuItem_2 {
}

// @public
export const menuItemStyles: FoundationElementTemplate<ElementStyles, MenuItemOptions>;

// @public
export const menuStyles: FoundationElementTemplate<ElementStyles>;

// @public (undocumented)
export const neutralColor: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillActiveDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillFocusDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillHoverDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillInputActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillInputActiveDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillInputFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillInputFocusDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillInputHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillInputHoverDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillInputRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const neutralFillInputRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillInputRestDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillLayerRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralFillLayerRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillLayerRestDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const neutralFillRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillRestDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStealthActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStealthActiveDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStealthFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStealthFocusDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStealthHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStealthHoverDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStealthRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const neutralFillStealthRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStealthRestDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStrongActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStrongActiveDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStrongFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStrongFocusDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStrongHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStrongHoverDelta: DesignToken<number>;

// @public (undocumented)
export const neutralFillStrongRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const neutralFillStrongRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralFillStrongRestDelta: DesignToken<number>;

// @public (undocumented)
export const neutralForegroundHint: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralForegroundHintRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralForegroundRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralForegroundRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralLayer1: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralLayer1Recipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralLayer2: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralLayer2Recipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralLayer3: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralLayer3Recipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralLayer4: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralLayer4Recipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralLayerCardContainer: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralLayerCardContainerRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralLayerFloating: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralLayerFloatingRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralPalette: DesignToken<Palette<Swatch>>;

// @public (undocumented)
export const neutralStrokeActive: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralStrokeActiveDelta: DesignToken<number>;

// @public (undocumented)
export const neutralStrokeDividerRecipe: DesignToken<ColorRecipe>;

// @public (undocumented)
export const neutralStrokeDividerRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralStrokeDividerRestDelta: DesignToken<number>;

// @public (undocumented)
export const neutralStrokeFocus: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralStrokeFocusDelta: DesignToken<number>;

// @public (undocumented)
export const neutralStrokeHover: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralStrokeHoverDelta: DesignToken<number>;

// @public (undocumented)
export const neutralStrokeRecipe: DesignToken<InteractiveColorRecipe>;

// @public (undocumented)
export const neutralStrokeRest: CSSDesignToken<Swatch>;

// @public (undocumented)
export const neutralStrokeRestDelta: DesignToken<number>;

// @public
export class NumberField extends NumberField_2 {
    appearance: NumberFieldAppearance;
}

// @public
export type NumberFieldAppearance = 'filled' | 'outline';

// @public
export const numberFieldStyles: FoundationElementTemplate<ElementStyles, NumberFieldOptions>;

// @public
class Option_2 extends ListboxOption {
}
export { Option_2 as Option }

// @public
export const optionStyles: FoundationElementTemplate<ElementStyles, ListboxOptionOptions>;

// @public
export interface Palette<T extends Swatch = Swatch> {
    // Warning: (ae-forgotten-export) The symbol "RelativeLuminance" needs to be exported by the entry point index.d.ts
    closestIndexOf(reference: RelativeLuminance): number;
    colorContrast(reference: Swatch, contrast: number, initialIndex?: number, direction?: 1 | -1): T;
    get(index: number): T;
    // (undocumented)
    readonly source: T;
    // (undocumented)
    readonly swatches: ReadonlyArray<T>;
}

// @public (undocumented)
export type PaletteRGB = Palette<SwatchRGB>;

// @public (undocumented)
export const PaletteRGB: Readonly<{
    create: typeof create;
    from: typeof from;
}>;

// @public
export class Picker extends Picker_2 {
}

// @public
export class PickerList extends PickerList_2 {
}

// @public
export class PickerListItem extends PickerListItem_2 {
}

// @public
export const pickerListItemStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class PickerMenu extends PickerMenu_2 {
    // (undocumented)
    connectedCallback(): void;
}

// @public
export class PickerMenuOption extends PickerMenuOption_2 {
}

// @public
export const pickerMenuOptionStyles: FoundationElementTemplate<ElementStyles>;

// @public
export const pickerMenuStyles: FoundationElementTemplate<ElementStyles>;

// @public
export const pickerStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class Progress extends BaseProgress {
}

// @public
export class ProgressRing extends BaseProgress {
}

// @public
export const progressRingStyles: FoundationElementTemplate<ElementStyles, ProgressRingOptions>;

// @public
export const progressStyles: FoundationElementTemplate<ElementStyles, ProgressOptions>;

// @public
export function provideJupyterDesignSystem(element?: HTMLElement): DesignSystem;

// @public
export class Radio extends Radio_2 {
}

// @public
export class RadioGroup extends RadioGroup_2 {
    constructor();
    // (undocumented)
    ariaInvalidChanged(): void;
}

// @public
export const radioGroupStyles: FoundationElementTemplate<ElementStyles>;

// @public
export const radioStyles: FoundationElementTemplate<ElementStyles, RadioOptions>;

// @public (undocumented)
export const radioTemplate: FoundationElementTemplate<ViewTemplate<Radio>, RadioOptions>;

// @public @deprecated (undocumented)
export interface Recipe<T> {
    // (undocumented)
    evaluate(element: HTMLElement, reference?: Swatch): T;
}

// @public
export class Search extends Search_2 {
    appearance: SearchAppearance;
}

// @public
export type SearchAppearance = 'filled' | 'outline';

// @public (undocumented)
export const searchStyles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;

// @public
export class Select extends Select_2 {
    autoWidth: boolean;
    protected autoWidthChanged(prev: boolean | undefined, next: boolean): void;
    // @internal (undocumented)
    connectedCallback(): void;
    // @internal (undocumented)
    protected listboxScrollWidthChanged(): void;
    // @internal
    protected maxHeightChanged(prev: number | undefined, next: number): void;
    // @deprecated
    minimal: boolean;
    // @internal @override
    multipleChanged(prev: boolean | undefined, next: boolean): void;
    scale?: SelectScale;
    protected setAutoWidth(): void;
    // (undocumented)
    setPositioning(): void;
    // @internal @override
    protected sizeChanged(prev: number | undefined, next: number): void;
    // @internal
    slottedOptionsChanged(prev: Element[] | undefined, next: Element[]): void;
    // @internal
    protected updateComputedStylesheet(): void;
}

// @public
export type SelectScale = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';

// @public
export const selectStyles: FoundationElementTemplate<ElementStyles, SelectOptions>;

// @public
export class Skeleton extends Skeleton_2 {
}

// @public
export const skeletonStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class Slider extends Slider_2 {
}

// @public
export class SliderLabel extends SliderLabel_2 {
    // (undocumented)
    protected sliderOrientationChanged(): void;
}

// @public
export const sliderLabelStyles: FoundationElementTemplate<ElementStyles>;

// @public
export const sliderStyles: FoundationElementTemplate<ElementStyles, SliderOptions>;

// @public
export const StandardLuminance: {
    readonly LightMode: 1;
    readonly DarkMode: 0.23;
};

// @public
export type StandardLuminance = (typeof StandardLuminance)[keyof typeof StandardLuminance];

// @public (undocumented)
export const strokeWidth: CSSDesignToken<number>;

// @public
export interface Swatch extends RelativeLuminance {
    // (undocumented)
    contrast(target: RelativeLuminance): number;
    // (undocumented)
    toColorString(): string;
}

// @public (undocumented)
export interface SwatchRGB extends Swatch {
    // (undocumented)
    b: number;
    // (undocumented)
    g: number;
    // (undocumented)
    r: number;
}

// @public (undocumented)
export const SwatchRGB: Readonly<{
    create(r: number, g: number, b: number): SwatchRGB;
    from(obj: {
        r: number;
        g: number;
        b: number;
    }): SwatchRGB;
}>;

// @public
export class Switch extends Switch_2 {
}

// @public
export const switchStyles: FoundationElementTemplate<ElementStyles, SwitchOptions>;

// @public
export class Tab extends Tab_2 {
}

// @public
export class TabPanel extends TabPanel_2 {
}

// @public
export const tabPanelStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class Tabs extends Tabs_2 {
}

// @public
export const tabsStyles: FoundationElementTemplate<ElementStyles, TabsOptions>;

// @public
export const tabStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class TextArea extends TextArea_2 {
    appearance: TextAreaAppearance;
}

// @public
export type TextAreaAppearance = 'filled' | 'outline';

// @public
export const textAreaStyles: FoundationElementTemplate<ElementStyles>;

// @public
export class TextField extends TextField_2 {
    appearance: TextFieldAppearance;
}

// @public
export type TextFieldAppearance = 'filled' | 'outline';

// @public
export const textFieldStyles: FoundationElementTemplate<ElementStyles, TextFieldOptions>;

// @public
export class Toolbar extends FoundationToolbar {
    // (undocumented)
    connectedCallback(): void;
}

// @public
export type ToolbarOptions = FoundationElementDefinition & StartEndOptions;

// @public
export const toolbarStyles: FoundationElementTemplate<ElementStyles, ToolbarOptions_2>;

// @public
export class Tooltip extends Tooltip_2 {
}

// @public
export const tooltipStyles: (context: ElementDefinitionContext, definition: FoundationElementDefinition) => ElementStyles;

// @public
export class TreeItem extends TreeItem_2 {
}

// @public
export const treeItemStyles: FoundationElementTemplate<ElementStyles, TreeItemOptions>;

// @public
export class TreeView extends TreeView_2 {
}

// @public
export const treeViewStyles: FoundationElementTemplate<ElementStyles>;

// @public (undocumented)
export const typeRampBaseFontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampBaseLineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampMinus1FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampMinus1LineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampMinus2FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampMinus2LineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus1FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus1LineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus2FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus2LineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus3FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus3LineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus4FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus4LineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus5FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus5LineHeight: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus6FontSize: CSSDesignToken<string>;

// @public (undocumented)
export const typeRampPlus6LineHeight: CSSDesignToken<string>;

// @public
export const verticalSliderLabelStyles: ElementStyles;

// Warnings were encountered during analysis:
//
// dist/dts/color/palette.d.ts:48:5 - (ae-forgotten-export) The symbol "create" needs to be exported by the entry point index.d.ts
// dist/dts/color/palette.d.ts:49:5 - (ae-forgotten-export) The symbol "from" needs to be exported by the entry point index.d.ts
// dist/dts/custom-elements.d.ts:200:5 - (ae-incompatible-release-tags) The symbol "jpDesignSystemProvider" is marked as @public, but its signature references "DesignSystemProvider" which is marked as @internal

// (No @packageDocumentation comment for this package)

```
