declare module '@uif-js/component' {
	import * as PackageCore from '@uif-js/core'
	import * as Self from '@uif-js/component'

	export class AccordionItemHeader extends PackageCore.Component {
		constructor(options?: Self.AccordionItemHeader.Options);

		label: (string | PackageCore.Translation);

		icon: object;

		contextControls: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

		actionControls: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

		expanded: boolean;

		defaultExpanded: boolean;

		expandedIcon: boolean;

		setLabel(label: string, reason: string): void;

		setIcon(icon: (PackageCore.ImageMetadata | null)): void;

		setExpandedIcon(icon: (PackageCore.ImageMetadata | null)): void;

		setExpanded(expanded: boolean): void;

		static Event: Self.AccordionItemHeader.EventTypes;

	}

	export namespace AccordionItemHeader {
		interface EventTypes extends PackageCore.Component.EventTypes {
			EXPANDED: string;

		}

		interface Options extends PackageCore.Component.Options {
			icon?: Self.Image.Source;

			label?: (string | PackageCore.Translation);

			contextControls?: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

			actionControls?: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

			expanded?: boolean;

			defaultExpanded?: boolean;

			expandedIcon?: Self.Image.Source;

		}

	}

	export class AccordionPanel extends PackageCore.Component {
		constructor(options?: Self.AccordionPanel.Options);

		items: globalThis.Array<Self.AccordionPanelItem>;

		element: Self.AccordionPanel.Element;

		components: globalThis.Array<PackageCore.Component>;

		children: PackageCore.VDom.Children;

		length: number;

		empty: boolean;

		orientation: Self.AccordionPanel.Orientation;

		fullyCollapsible: boolean;

		multiple: boolean;

		outerGap: (Self.AccordionPanel.GapSize | Self.AccordionPanel.GapSizeObject);

		expandedCount: number;

		decorator: (PackageCore.Decorator | null);

		defaultItemOptions: Self.AccordionPanel.ItemProps;

		add(component: (Self.AccordionPanel.ItemConfiguration | globalThis.Array<Self.AccordionPanel.ItemConfiguration>)): Self.AccordionPanel;

		remove(componentOrIndex: (PackageCore.Component | number | globalThis.Array<(PackageCore.Component | number)>)): Self.AccordionPanel;

		move(args: {component: PackageCore.Component; index?: number; reason?: string}): Self.AccordionPanel;

		clear(): Self.AccordionPanel;

		replace(currentComponent: (PackageCore.Component | number), newComponent: PackageCore.Component): Self.AccordionPanel;

		has(component: PackageCore.Component): boolean;

		itemForComponent(component: PackageCore.Component): Self.AccordionPanelItem;

		itemAtIndex(index: number): Self.AccordionPanelItem;

		setOrientation(orientation: Self.AccordionPanel.Orientation): void;

		setMultiple(multiple: boolean): void;

		setFullyCollapsible(value: boolean): void;

		expand(component: (PackageCore.Component | number)): void;

		collapse(component: (PackageCore.Component | number)): void;

		toggle(component: (PackageCore.Component | number)): void;

		collapseAll(): void;

		expandAll(): void;

		collapseOthers(component: (PackageCore.Component | number)): void;

		isExpanded(component: (PackageCore.Component | number)): boolean;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		static horizontal(items?: (object | globalThis.Array<PackageCore.Component> | globalThis.Array<Self.AccordionPanelItem.Options>)): Self.AccordionPanel;

		static Horizontal(): PackageCore.JSX.Element;

		static vertical(items?: (object | globalThis.Array<PackageCore.Component> | globalThis.Array<Self.AccordionPanelItem.Options>)): Self.AccordionPanel;

		static Vertical(): PackageCore.JSX.Element;

		static Item(props?: Self.AccordionPanel.JsxItemProps): PackageCore.JSX.Element;

		static Event: Self.AccordionPanel.EventTypes;

	}

	export namespace AccordionPanel {
		interface BaseItemProps {
			label?: string;

			actionControls?: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

			contextControls?: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

			expanded?: boolean;

			defaultExpanded?: boolean;

			icon?: Self.Image.Source;

			expandedIcon?: Self.Image.Source;

		}

		interface JsxItemProps extends Self.AccordionPanel.BaseItemProps {
			children?: PackageCore.VDom.Children;

			key?: any;

		}

		interface ItemProps extends Self.AccordionPanel.BaseItemProps {
		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ADDED: string;

			ITEM_REMOVED: string;

			ITEM_MOVED: string;

			ITEM_EXPANDED: string;

		}

		interface StructuredItemConfiguration {
			component: PackageCore.Component;

			options?: Self.AccordionPanel.ItemProps;

		}

		interface FlatItemConfiguration extends Self.AccordionPanel.ItemProps {
			component: PackageCore.Component;

		}

		type ItemConfiguration = (PackageCore.Component | Self.AccordionPanel.StructuredItemConfiguration | Self.AccordionPanel.FlatItemConfiguration);

		interface GapSizeObject {
			top?: Self.AccordionPanel.GapSize;

			bottom?: Self.AccordionPanel.GapSize;

			start?: Self.AccordionPanel.GapSize;

			end?: Self.AccordionPanel.GapSize;

			horizontal?: Self.AccordionPanel.GapSize;

			vertical?: Self.AccordionPanel.GapSize;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			decorator?: PackageCore.Decorator;

			fullyCollapsible?: boolean;

			items?: (Self.AccordionPanel.ItemConfiguration | globalThis.Array<Self.AccordionPanel.ItemConfiguration>);

			multiple?: boolean;

			orientation?: Self.AccordionPanel.Orientation;

			outerGap?: (Self.AccordionPanel.GapSize | Self.AccordionPanel.GapSizeObject);

			element?: Self.AccordionPanel.Element;

			defaultItemOptions?: Self.AccordionPanel.ItemProps;

		}

		export import VisualStyle = Self.AccordionVisualStyle;

		enum Orientation {
			VERTICAL,
			HORIZONTAL,
		}

		export import GapSize = Self.GapSize;

		export import Decorator = PackageCore.Decorator;

		export import Element = PackageCore.Html.Element.Section;

	}

	export class AccordionPanelItem extends PackageCore.Component {
		constructor(options: Self.AccordionPanelItem.Options);

		component: PackageCore.Component;

		value: any;

		children: PackageCore.VDom.Children;

		header: Self.AccordionItemHeader;

		expanded: boolean;

		icon: Self.Image.Source;

		expandedIcon: Self.Image.Source;

		label: (string | PackageCore.Translation);

		contextControls: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

		actionControls: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

		setExpanded(value: boolean): void;

		static Event: Self.AccordionPanelItem.EventTypes;

	}

	export namespace AccordionPanelItem {
		interface Options {
			children?: PackageCore.VDom.Children;

			label?: (string | PackageCore.Translation);

			expanded?: boolean;

			icon?: Self.Image.Source;

			expandedIcon?: Self.Image.Source;

			contextControls?: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

			actionControls?: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

			value?: any;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			EXPANDED: string;

		}

	}

	enum AccordionVisualStyle {
		DEFAULT,
		LIGHT,
	}

	export class ActionCell extends Self.GridCell {
		constructor();

		actions: globalThis.Array<any>;

		defaultActions: globalThis.Array<any>;

		menuActions: globalThis.Array<any>;

		setActions(actions: globalThis.Array<any>): void;

		showAction(actionId: string, visible: boolean): void;

		enableAction(actionId: string, enabled: boolean): void;

		openMenu(): void;

		closeMenu(): void;

	}

	export namespace ActionCell {
	}

	export class ActionColumn extends Self.GridColumn {
		constructor(options: Self.ActionColumn.Options);

		actions: (globalThis.Array<Self.ActionColumn.ActionDefinition> | Self.ActionColumn.ActionProvider);

		showAction(actionId: string, visible: boolean): void;

		enableAction(actionId: string, enabled: boolean): void;

	}

	export namespace ActionColumn {
		interface Options extends Self.GridColumn.Options {
			actions?: (globalThis.Array<Self.ActionColumn.ActionDefinition> | Self.ActionColumn.ActionProvider);

		}

		type ActionProvider = (cell: Self.GridCell) => globalThis.Array<Self.ActionColumn.ActionDefinition>;

		interface ActionDefinition {
			id?: string;

			default?: boolean;

			icon?: Self.Image.Source;

			label?: (string | PackageCore.Translation);

			action?: () => void;

			type?: Self.Button.Type;

		}

		export import Cell = Self.ActionCell;

	}

	class AdminDocsSystemHeader extends PackageCore.Component {
		constructor(options?: Self.AdminDocsSystemHeader.Options);

		grid: PackageCore.JSX.Element;

		homeButtonOptions: Self.Button.Options;

		logos: globalThis.Array<PackageCore.JSX.Element>;

		logoutButtonOptions: Self.Button.Options;

		environment: Self.AdminDocsSystemHeader.Environment;

	}

	namespace AdminDocsSystemHeader {
		interface Options extends PackageCore.Component.Options {
			grid?: PackageCore.JSX.Element;

			homeButtonOptions?: Self.Button.Options;

			logos?: globalThis.Array<PackageCore.JSX.Element>;

			logoutButtonOptions?: Self.Button.Options;

			environment?: Self.SystemHeader.Environment;

		}

		enum Environment {
			PRODUCTION,
			RELEASE_PREVIEW,
			SANDBOX,
			F,
			SNAP,
			DEBUGGER,
		}

	}

	export class Agenda extends PackageCore.Component {
		constructor(options?: Self.Agenda.Options);

		dayViewConfig: Self.AgendaWeekTimeView.Options;

		events: globalThis.Array<any>;

		highlightWeekends: boolean;

		selectedView: Self.Agenda.CalendarView;

		monthViewConfig: Self.AgendaMonthView.Options;

		readOnly: boolean;

		viewDate: PackageCore.Date;

		weekViewConfig: Self.AgendaWeekTimeView.Options;

		addEvent(event?: object, options?: {reason?: Self.Agenda.Reason}): void;

		removeEvent(event?: object, options?: {reason?: Self.Agenda.Reason}): void;

		static Event: Self.Agenda.EventTypes;

	}

	export namespace Agenda {
		interface EventData {
			name: (string | number | PackageCore.Translation);

			description?: (string | number | PackageCore.Translation);

			start: PackageCore.Date;

			end: PackageCore.Date;

			wholeDay?: boolean;

			color?: Self.AgendaEvent.Color;

			badge?: (string | number | PackageCore.Translation);

		}

		interface Options extends PackageCore.Component.Options {
			viewDate?: PackageCore.Date;

			selectedView?: Self.Agenda.CalendarView;

			events?: globalThis.Array<Self.Agenda.EventData>;

			readOnly?: boolean;

			highlightWeekends?: boolean;

			monthViewConfig?: Self.AgendaMonthView.Options;

			weekViewConfig?: Self.AgendaWeekTimeView.Options;

			dayViewConfig?: Self.AgendaWeekTimeView.Options;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			EVENT_ADD: symbol;

			EVENT_REMOVE: symbol;

		}

		export import Reason = Self.AgendaConstant.Reason;

		enum CalendarView {
			MONTH,
			WEEK,
			DAY,
			AGENDA,
		}

		export import View = Self.AgendaView;

		export import DayView = Self.AgendaDayView;

		export import MonthView = Self.AgendaMonthView;

		export import WeekTimeView = Self.AgendaWeekTimeView;

		export import AgendaEvent = Self.AgendaEvent;

	}

	namespace AgendaConstant {
		enum Event {
			EVENT_ADD,
			EVENT_REMOVE,
		}

		enum Reason {
			USER_CALL,
			INTERNAL_CALL,
		}

	}

	class AgendaDayTimeCell extends PackageCore.Component {
		constructor(options?: Self.AgendaDayTimeCell.Options);

		clickAction: (((date: PackageCore.Date) => void) | null);

		time: PackageCore.Date;

	}

	namespace AgendaDayTimeCell {
		interface Options extends PackageCore.Component.Options {
			time?: PackageCore.Date;

			clickAction?: (date: PackageCore.Date) => void;

		}

	}

	export class AgendaDayTimeGrid extends PackageCore.Component {
		constructor(options?: Self.AgendaDayTimeGrid.Options);

		background: Self.AgendaDayTimeGrid.Background;

		timeClickAction: (((time: (PackageCore.Date | PackageCore.Time)) => void) | null);

		eventClickAction: (((event: Self.Agenda.EventData) => void) | null);

		events: globalThis.Array<Self.Agenda.EventData>;

		readOnly: boolean;

		viewDate: PackageCore.Date;

		addEvent(event?: object, options?: {reason?: Self.AgendaDayTimeGrid.Reason}): void;

		removeEvent(event?: object, options?: {reason?: Self.AgendaDayTimeGrid.Reason}): void;

		static Event: Self.Agenda.EventTypes;

	}

	export namespace AgendaDayTimeGrid {
		interface Options extends PackageCore.Component.Options {
			viewDate?: PackageCore.Date;

			events?: globalThis.Array<Self.Agenda.EventData>;

			background?: Self.AgendaDayTimeGrid.Background;

			readOnly?: boolean;

			timeClickAction?: (time: (PackageCore.Date | PackageCore.Time)) => void;

			eventClickAction?: (event: Self.Agenda.EventData) => void;

		}

		export import Reason = Self.AgendaConstant.Reason;

		enum Background {
			WEAK,
			MEDIUM,
			STRONG,
		}

	}

	export class AgendaDayView extends PackageCore.Component {
		constructor(options?: Self.AgendaDayView.Options);

		background: Self.AgendaDayView.Background;

		clickAction: (((date: PackageCore.Date) => void) | null);

		eventClickAction: (((event: Self.Agenda.EventData) => void) | null);

		description: (string | number | PackageCore.Translation);

		icon: Self.Image.Source;

		events: globalThis.Array<Self.Agenda.EventData>;

		eventsLimit: number;

		showHeader: boolean;

		showLongViewDate: boolean;

		showMoreAction: (date: PackageCore.Date) => void;

		summary: Self.AgendaDayView.Summary;

		readOnly: boolean;

		viewDate: PackageCore.Date;

		addEvent(event?: object, options?: {reason?: Self.AgendaDayView.Reason}): void;

		removeEvent(event?: object, options?: {reason?: Self.AgendaDayView.Reason}): void;

		static Event: Self.Agenda.EventTypes;

	}

	export namespace AgendaDayView {
		interface Options extends PackageCore.Component.Options {
			viewDate?: PackageCore.Date;

			description?: (string | number | PackageCore.Translation);

			icon?: PackageCore.ImageMetadata;

			events?: globalThis.Array<Self.Agenda.EventData>;

			summary?: Self.AgendaDayView.Summary;

			background?: Self.AgendaDayView.Background;

			eventsLimit?: number;

			showHeader?: boolean;

			showLongViewDate?: boolean;

			readOnly?: boolean;

			clickAction?: (date: PackageCore.Date) => void;

			eventClickAction?: (event: Self.Agenda.EventData) => void;

			showMoreAction?: (date: PackageCore.Date) => void;

		}

		interface Summary {
			text: (string | PackageCore.Translation);

			action: (date: PackageCore.Date) => void;

		}

		export import Reason = Self.AgendaConstant.Reason;

		enum Background {
			WEAK,
			MEDIUM,
			STRONG,
		}

	}

	export class AgendaEvent extends PackageCore.Component {
		constructor(options?: Self.AgendaEvent.Options);

		event: Self.Agenda.EventData;

		badge: (string | number | PackageCore.Translation);

		clickAction: (((event: Self.Agenda.EventData) => void) | null);

		readOnly: boolean;

	}

	export namespace AgendaEvent {
		interface Options extends PackageCore.Component.Options {
			event?: Self.Agenda.EventData;

			showDescription?: boolean;

			badge?: (string | number | PackageCore.Translation);

			clickAction?: (event: Self.Agenda.EventData) => void;

		}

		enum Color {
			AZURE,
			RED,
			PINK,
			PURPLE,
			THEMED,
			NEUTRAL,
		}

	}

	class AgendaEventPlaceholder extends PackageCore.Component {
		constructor(options?: Self.AgendaEventPlaceholder.Options);

		dark: boolean;

	}

	namespace AgendaEventPlaceholder {
		interface Options extends PackageCore.Component.Options {
			dark?: boolean;

		}

	}

	export class AgendaMonthView extends PackageCore.Component {
		constructor(options?: Self.AgendaMonthView.Options);

		daysConfig: (date: PackageCore.Date) => Self.AgendaDayView.Options;

		events: globalThis.Array<Self.Agenda.EventData>;

		highlightWeekends: boolean;

		showHeader: boolean;

		startingDay: number;

		readOnly: boolean;

		viewDate: PackageCore.Date;

		weeksCount: number;

		dayClickAction: (((date: PackageCore.Date) => void) | null);

		eventClickAction: (((event: Self.Agenda.EventData) => void) | null);

		showMoreAction: (((date: PackageCore.Date) => void) | null);

		addEvent(event?: object, options?: {reason?: Self.AgendaMonthView.Reason}): void;

		removeEvent(event?: object, options?: {reason?: Self.AgendaMonthView.Reason}): void;

		getEventsFromDate(date?: PackageCore.Date): void;

		static Event: Self.Agenda.EventTypes;

	}

	export namespace AgendaMonthView {
		interface Options extends PackageCore.Component.Options {
			viewDate?: PackageCore.Date;

			startingDay?: number;

			events?: globalThis.Array<Self.Agenda.EventData>;

			showHeader?: boolean;

			highlightWeekends?: boolean;

			weeksCount?: number;

			dayClickAction?: (date: PackageCore.Date) => void;

			eventClickAction?: (event: Self.Agenda.EventData) => void;

			showMoreAction?: (date: PackageCore.Date) => void;

			daysConfig?: (date: PackageCore.Date) => Self.AgendaDayView.Options;

		}

		export import Reason = Self.AgendaConstant.Reason;

	}

	export class AgendaView extends PackageCore.Component {
		constructor(options?: Self.AgendaView.Options);

		events: globalThis.Array<Self.Agenda.EventData>;

		readOnly: boolean;

		showDate: boolean;

		showDay: boolean;

		viewDate: PackageCore.Date;

		eventClickAction: (((event: Self.Agenda.EventData) => void) | null);

	}

	export namespace AgendaView {
		interface Options extends PackageCore.Component.Options {
			events?: globalThis.Array<Self.Agenda.EventData>;

			viewDate?: PackageCore.Date;

			showDate?: boolean;

			showDay?: boolean;

			readOnly?: boolean;

			eventClickAction?: (event: Self.Agenda.EventData) => void;

		}

	}

	export class AgendaViewHeader extends PackageCore.Component {
		constructor(options?: Self.AgendaViewHeader.Options);

		highlightedDate: PackageCore.Date;

		length: number;

		showDate: boolean;

		showDay: boolean;

		startDate: PackageCore.Date;

	}

	export namespace AgendaViewHeader {
		interface Options extends PackageCore.Component.Options {
			startDate?: PackageCore.Date;

			length?: number;

			showDate?: boolean;

			showDay?: boolean;

			highlightedDate?: PackageCore.Date;

		}

	}

	export class AgendaWeekTimeView extends PackageCore.Component {
		constructor(options?: Self.AgendaWeekTimeView.Options);

		daysCount: object;

		daysConfig: (date: PackageCore.Date) => Self.AgendaDayView.Options;

		events: globalThis.Array<Self.Agenda.EventData>;

		showHeader: boolean;

		readOnly: boolean;

		startingDay: number;

		viewDate: PackageCore.Date;

		timeClickAction: (((date: PackageCore.Date) => void) | null);

		dayClickAction: (((date: PackageCore.Date) => void) | null);

		eventClickAction: (((event: Self.Agenda.EventData) => void) | null);

		addEvent(event?: object, options?: {reason?: Self.AgendaWeekTimeView.Reason}): void;

		removeEvent(event?: object, options?: {reason?: Self.AgendaWeekTimeView.Reason}): void;

		getEventsFromDate(date?: PackageCore.Date): void;

		static Event: Self.Agenda.EventTypes;

	}

	export namespace AgendaWeekTimeView {
		interface Options extends PackageCore.Component.Options {
			viewDate?: PackageCore.Date;

			events?: globalThis.Array<Self.Agenda.EventData>;

			showHeader?: boolean;

			readOnly?: boolean;

			startingDay?: number;

			daysCount?: number;

			timeClickAction?: (date: PackageCore.Date) => void;

			dayClickAction?: (date: PackageCore.Date) => void;

			eventClickAction?: (event: Self.Agenda.EventData) => void;

			daysConfig?: (date: PackageCore.Date) => Self.AgendaDayView.Options;

		}

		export import Reason = Self.AgendaConstant.Reason;

	}

	export class ApplicationHeader extends PackageCore.Component {
		constructor(options?: Self.ApplicationHeader.Options);

		title: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		subtitle: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		badge: (string | number | PackageCore.Translation | Self.Badge.Options);

		icon: (object | globalThis.Array<any> | string | PackageCore.ImageMetadata | PackageCore.Component | PackageCore.JSX.Element);

		actions: (Self.ApplicationHeader.ActionGroup | globalThis.Array<Self.ApplicationHeader.ActionGroup>);

		links: globalThis.Array<Self.ApplicationHeader.LinkDefinition>;

		tools: (PackageCore.Component | PackageCore.JSX.Element);

		outerGap: Self.ApplicationHeader.GapSize;

		titlePanelCollapsible: boolean;

		titlePanelCollapsed: boolean;

		setTitle(title: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element)): void;

		setSubtitle(subtitle: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element)): void;

		setBadge(badge: (string | number | PackageCore.Translation)): void;

		setIcon(icon: (object | globalThis.Array<any> | string | PackageCore.ImageMetadata)): void;

		setLinks(links: globalThis.Array<Self.ApplicationHeader.LinkDefinition>): void;

		setActions(actions: globalThis.Array<Self.ApplicationHeader.ActionDefinition>): void;

		setTools(tools: (PackageCore.Component | PackageCore.JSX.Element)): void;

		getAction(actionId?: number): (Self.ApplicationHeader.ActionHandle | null);

	}

	export namespace ApplicationHeader {
		interface LinkDefinition {
			label?: (string | PackageCore.Translation);

			url?: (string | PackageCore.Url);

			route?: (string | PackageCore.Route | Self.Link.Route);

		}

		interface ActionDefinition {
			action?: () => void;

			enabled?: boolean;

			id?: string;

			label?: (string | PackageCore.Translation);

			type?: Self.ApplicationHeader.ActionType;

			automationId?: string;

		}

		interface ActionHandle {
			setEnabled?: (enabled: boolean) => Self.ApplicationHeader.ActionHandle;

			setLabel?: (label: (string | PackageCore.Translation)) => Self.ApplicationHeader.ActionHandle;

		}

		type ActionGroup = globalThis.Array<(Self.ApplicationHeader.ActionDefinition | PackageCore.JSX.Element)>;

		interface GapSizeObject {
			top?: Self.ApplicationHeader.GapSize;

			bottom?: Self.ApplicationHeader.GapSize;

			start?: Self.ApplicationHeader.GapSize;

			end?: Self.ApplicationHeader.GapSize;

			horizontal?: Self.ApplicationHeader.GapSize;

			vertical?: Self.ApplicationHeader.GapSize;

		}

		interface Options extends PackageCore.Component.Options {
			actions?: (Self.ApplicationHeader.ActionGroup | globalThis.Array<Self.ApplicationHeader.ActionGroup>);

			icon?: (object | globalThis.Array<any> | string | PackageCore.ImageMetadata | PackageCore.Component | PackageCore.JSX.Element);

			links?: globalThis.Array<Self.ApplicationHeader.LinkDefinition>;

			badge?: (string | number | PackageCore.Translation | Self.Badge.Options);

			subtitle?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			title?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			tools?: (PackageCore.Component | PackageCore.JSX.Element);

			outerGap?: (Self.ApplicationHeader.GapSize | Self.ApplicationHeader.GapSizeObject);

			titlePanelCollapsible?: boolean;

			titlePanelCollapsed?: boolean;

		}

		enum ActionType {
			PRIMARY,
			SECONDARY,
			GHOST,
		}

		export import GapSize = Self.GapSize;

	}

	export class Avatar extends PackageCore.Component {
		constructor(options?: Self.Avatar.Options);

		content: (string | PackageCore.Translation | PackageCore.ImageMetadata | PackageCore.ImageMetadata.Options);

		presentation: boolean;

		size: Self.Avatar.Size;

		color: (Self.Avatar.Color | Self.Avatar.RefreshedColor | Self.Avatar.RedwoodColor);

		borderRadius: Self.Avatar.BorderRadius;

		setContent(content: (string | PackageCore.Translation | object | PackageCore.ImageMetadata)): void;

		setSize(size: Self.Avatar.Size): void;

		setColor(color: (Self.Avatar.Color | Self.Avatar.RefreshedColor | Self.Avatar.RedwoodColor)): void;

		setBorderRadius(borderRadius: Self.Avatar.BorderRadius): void;

		setPresentation(presentation: boolean): void;

	}

	export namespace Avatar {
		interface Options extends PackageCore.Component.Options {
			borderRadius?: Self.Avatar.BorderRadius;

			content: (string | PackageCore.Translation | PackageCore.ImageMetadata | PackageCore.ImageMetadata.Options);

			presentation?: boolean;

			size?: Self.Avatar.Size;

			color?: (Self.Avatar.Color | Self.Avatar.RefreshedColor | Self.Avatar.RedwoodColor);

		}

		export import Size = PackageCore.ImageConstant.Size;

		enum Color {
			DEFAULT,
			THEMED,
		}

		enum RefreshedColor {
			PURPLE,
			YELLOW,
			GREEN,
			PINK,
			TURQUOISE,
			BROWN,
			LIGHT,
		}

		enum RedwoodColor {
			BLUE,
			GRAY,
			LILAC,
			TEAL,
			PINK,
			PURPLE,
			GREEN,
			SLATE,
		}

		export import BorderRadius = PackageCore.ImageConstant.BorderRadius;

	}

	export class Badge extends PackageCore.Component {
		constructor(options?: Self.Badge.Options);

		content: (string | number | PackageCore.Translation | PackageCore.JSX.Element);

		children: PackageCore.VDom.Children;

		type: Self.Badge.Type;

		size: Self.Badge.Size;

		start: boolean;

		end: boolean;

		setContent(content: (string | number | PackageCore.Translation)): void;

		setType(type: Self.Badge.Type): void;

		setSize(size: Self.Badge.Size): void;

		setStart(start: boolean): void;

		setEnd(end: boolean): void;

	}

	export namespace Badge {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (string | number | PackageCore.Translation);

			end?: boolean;

			type?: Self.Badge.Type;

			size?: Self.Badge.Size;

			start?: boolean;

		}

		enum Type {
			SOLID,
			SUBTLE,
		}

		enum Size {
			DEFAULT,
			SMALL,
		}

	}

	export class Banner extends PackageCore.Component {
		constructor(options?: Self.Banner.Options);

		button: (Self.Button.Options | null);

		color: Self.Banner.Color;

		content: (PackageCore.Component | PackageCore.JSX.Element);

		closeAction: (Self.Button.ActionCallback | null);

		dontShowAgainAction: (Self.Button.ActionCallback | null);

		imageUrl: (string | null);

		title: (null | string | number | PackageCore.Translation);

		showControls: boolean;

	}

	export namespace Banner {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (PackageCore.Component | PackageCore.JSX.Element);

			title?: (string | number | PackageCore.Translation);

			imageUrl?: string;

			color?: Self.Banner.Color;

			showControls?: boolean;

			button?: Self.Button.Options;

			dontShowAgainAction?: Self.CheckBox.ActionCallback;

			closeAction?: Self.Button.ActionCallback;

		}

		enum Color {
			BLUE,
			BLUE_DARK,
			GREEN,
			ORANGE,
		}

		enum I18n {
			DONT_SHOW_AGAIN,
			CLOSE,
		}

	}

	export class BannerMessage extends PackageCore.Component {
		constructor(options?: Self.BannerMessage.Options);

		type: Self.BannerMessage.Type;

		icon: Self.Image.Source;

		layout: Self.BannerMessage.Layout;

		title: (string | PackageCore.Translation);

		content: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		children: PackageCore.VDom.Children;

		showCloseButton: boolean;

		close(options?: object): void;

		static Event: Self.BannerMessage.EventTypes;

	}

	export namespace BannerMessage {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			layout?: Self.BannerMessage.Layout;

			showCloseButton?: boolean;

			title?: (string | PackageCore.Translation);

			icon?: Self.Image.Source;

			type?: Self.BannerMessage.Type;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			CLOSED: string;

		}

		export import Type = PackageCore.UserMessageService.MessageType;

		enum Layout {
			DEFAULT,
			INLINE,
		}

		enum Reason {
			CALL,
			CLOSE_BUTTON,
		}

	}

	export class BannerPanel extends PackageCore.Component {
		constructor(options?: Self.BannerPanel.Options);

		messages: globalThis.Array<Self.BannerMessage>;

		manual: boolean;

		add(message: (Self.BannerMessage | globalThis.Array<Self.BannerMessage>)): void;

		remove(message: Self.BannerMessage): void;

		clear(): void;

		createUserMessage(message: PackageCore.UserMessageService.MessageOptions): Self.BannerMessage;

		connect(service: PackageCore.UserMessageService): void;

		disconnect(): void;

	}

	export namespace BannerPanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			messages?: globalThis.Array<Self.BannerMessage>;

			position?: Self.BannerPanel.Position;

			manual?: boolean;

		}

		enum Position {
			RELATIVE,
			ABSOLUTE,
		}

	}

	namespace BaseBundle {
	}

	class BlankPortlet extends PackageCore.Component {
		constructor(options?: Self.BlankPortlet.Options);

	}

	namespace BlankPortlet {
		interface Options extends PackageCore.Component.Options {
		}

	}

	export class BloomLine extends PackageCore.Component {
		constructor(options?: Self.BloomLine.Options);

		animation: boolean;

	}

	export namespace BloomLine {
		interface Options extends PackageCore.Component.Options {
			animation?: boolean;

		}

	}

	export class BloomPanel extends PackageCore.Component {
		constructor(options?: Self.BloomPanel.Options);

		active: boolean;

		content: any;

		children: PackageCore.VDom.Children;

	}

	export namespace BloomPanel {
		interface Options extends PackageCore.Component.Options {
			active?: boolean;

		}

	}

	export class Breadcrumbs extends PackageCore.Component {
		constructor(options?: Self.Breadcrumbs.Options);

		children: PackageCore.VDom.Children;

		items: globalThis.Array<Self.BreadcrumbsItem.Options>;

		expanded: boolean;

		size: Self.Breadcrumbs.Size;

		expandStrategy: Self.Breadcrumbs.ExpandStrategy;

		overflowStrategy: Self.Breadcrumbs.OverflowStrategy;

		separatorSymbol: (Self.Breadcrumbs.SeparatorSymbol | string);

		setExpanded(value: boolean): void;

		toggleExpanded(): void;

		autoCollapse(): void;

		private parseChildren(children: PackageCore.VDom.Children): globalThis.Array<Self.BreadcrumbsItem.Options>;

		private createExpandedItems(): globalThis.Array<Self.BreadcrumbsItem>;

		private createCollapsedItems(): globalThis.Array<Self.BreadcrumbsItem>;

		private createCollapsedItem(): Self.BreadcrumbsItem;

		private createItems(): globalThis.Array<Self.BreadcrumbsItem>;

		static getStyles(): void;

		static getRefreshedStyles(): void;

		static getRedwoodStyles(): void;

		static Item(props?: Self.BreadcrumbsItem.BaseProps): PackageCore.JSX.Element;

	}

	export namespace Breadcrumbs {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			expandStrategy?: Self.Breadcrumbs.ExpandStrategy;

			overflowStrategy?: Self.Breadcrumbs.OverflowStrategy;

			size?: Self.Breadcrumbs.Size;

			separatorSymbol?: (Self.Breadcrumbs.SeparatorSymbol | string);

			items?: globalThis.Array<Self.BreadcrumbsItem.Options>;

			expanded?: boolean;

		}

		export import Size = Self.BreadcrumbsItem.Size;

		export import SeparatorSymbol = Self.BreadcrumbsItem.SeparatorSymbol;

		export import IconPosition = Self.BreadcrumbsItem.IconPosition;

		export import ItemType = Self.BreadcrumbsItem.Type;

		enum ExpandStrategy {
			EXPAND,
			MENU,
			NONE,
		}

		enum OverflowStrategy {
			WRAP,
			COLLAPSE,
			NONE,
		}

	}

	export class BreadcrumbsItem extends PackageCore.Component {
		constructor(options?: Self.BreadcrumbsItem.Options);

		label: (string | number | PackageCore.Translation);

		icon: Self.Image.Source;

		iconPosition: Self.BreadcrumbsItem.IconPosition;

		size: Self.BreadcrumbsItem.Size;

		expandable: boolean;

		collapsible: boolean;

		separatorSymbol: (Self.BreadcrumbsItem.SeparatorSymbol | string);

		url: (string | PackageCore.Url);

		route: (string | PackageCore.Route | Self.Link.Route);

		type: Self.BreadcrumbsItem.Type;

		menu: globalThis.Array<object>;

		private createTextItem(): globalThis.Array<PackageCore.JSX.Element>;

		private createLinkItem(): PackageCore.JSX.Element;

		private createCollapsedItem(): PackageCore.JSX.Element;

		private createSeparator(): PackageCore.JSX.Element;

		private createMenuButton(): PackageCore.JSX.Element;

		static getStyles(): void;

		static getRefreshedStyles(): void;

		static getRedwoodStyles(): void;

		static Event: Self.BreadcrumbsItem.EventTypes;

	}

	export namespace BreadcrumbsItem {
		interface BaseProps extends PackageCore.Component.Options {
			icon?: Self.Image.Source;

			iconPosition?: Self.BreadcrumbsItem.IconPosition;

			collapsible?: boolean;

			url?: (string | PackageCore.Url);

			route?: (string | PackageCore.Route | Self.Link.Route);

			type?: Self.BreadcrumbsItem.Type;

			size?: Self.BreadcrumbsItem.Size;

			expandable?: boolean;

			separatorSymbol?: Self.BreadcrumbsItem.SeparatorSymbol;

			menu?: globalThis.Array<object>;

			children?: PackageCore.VDom.Children;

		}

		interface Options extends Self.BreadcrumbsItem.BaseProps {
			children?: PackageCore.VDom.Children;

			label?: (string | number | PackageCore.Translation);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			EXPANDED: symbol;

		}

		enum Type {
			TEXT,
			LINK,
			COLLAPSED,
		}

		enum Size {
			REGULAR,
			LARGE,
			LARGER,
		}

		enum IconPosition {
			START,
			END,
		}

		enum SeparatorSymbol {
			SLASH,
			DASH,
			GREATER_THAN,
		}

	}

	export class Button extends PackageCore.Component {
		constructor(options?: Self.Button.Options);

		startIcon: (PackageCore.ImageMetadata | null);

		endIcon: (PackageCore.ImageMetadata | null);

		action: Self.Button.ActionCallback;

		label: (null | string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		hasLabel: boolean;

		icon: (PackageCore.ImageMetadata | null);

		hasIcon: boolean;

		iconPosition: Self.Button.IconPosition;

		size: Self.Button.Size;

		type: Self.Button.Type;

		hierarchy: Self.Button.Hierarchy;

		behavior: Self.Button.Behavior;

		toggled: boolean;

		hasBadge: boolean;

		badge: (boolean | string | number | PackageCore.Translation | Self.Button.BadgeDefinition);

		nativeType: Self.Button.NativeType;

		onToggled: Self.Button.ToggledCallback;

		bloom: boolean;

		setLabel(label: (null | string | number | PackageCore.Translation | PackageCore.Component)): void;

		setIcon(icon: (PackageCore.ImageMetadata | null)): void;

		setBadge(badge: (boolean | string | number | PackageCore.Translation | Self.Button.BadgeDefinition)): void;

		setIconPosition(position: Self.Button.IconPosition): void;

		setSize(size: Self.Button.Size): void;

		setType(type: Self.Button.Type): void;

		setHierarchy(hierarchy: Self.Button.Hierarchy): void;

		click(): void;

		setToggled(toggled: boolean, options?: object): void;

		protected handleClicked(options: object): void;

		static toggle(options: Self.Button.ToggleButtonOptions): Self.Button;

		static Toggle(props: Self.Button.ToggleButtonOptions): PackageCore.JSX.Element;

		static Event: Self.Button.EventTypes;

	}

	export namespace Button {
		interface BadgeDefinition {
			text: (string | number | PackageCore.Translation);

			status?: PackageCore.Component.Status;

		}

		interface Options extends PackageCore.Component.Options {
			action?: Self.Button.ActionCallback;

			badge?: (boolean | string | number | PackageCore.Translation | Self.Button.BadgeDefinition);

			behavior?: Self.Button.Behavior;

			icon?: Self.Image.Source;

			startIcon?: Self.Image.Source;

			endIcon?: Self.Image.Source;

			iconPosition?: Self.Button.IconPosition;

			label?: (null | string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			size?: Self.Button.Size;

			toggled?: boolean;

			type?: Self.Button.Type;

			nativeType?: Self.Button.NativeType;

			onToggled?: Self.Button.ToggledCallback;

			bloom?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TOGGLED: string;

			ACTION: string;

		}

		type ActionCallback = (args: Self.Button.ActionArgs, sender: Self.Button) => void;

		interface ActionArgs {
			toggled: boolean;

			reason: string;

			button: Self.Button;

		}

		type ToggledCallback = (args: Self.Button.ToggledArgs, sender: Self.Button) => void;

		interface ToggledArgs {
			toggled: boolean;

			reason: string;

		}

		interface ToggleButtonOptions extends Self.Button.Options {
		}

		enum Size {
			SMALLER,
			SMALL,
			MEDIUM,
			LARGE,
		}

		enum IconPosition {
			LEFT,
			RIGHT,
			ABOVE,
			BELOW,
			HORIZONTAL,
		}

		enum Type {
			DEFAULT,
			PRIMARY,
			PURE,
			EMBEDDED,
			GHOST,
			DANGER,
			LINK,
			MONOCHROME,
		}

		enum ToggleType {
			DEFAULT,
			GHOST,
			PURE,
		}

		enum NativeType {
			BUTTON,
			SUBMIT,
			RESET,
		}

		enum Hierarchy {
			PRIMARY,
			SECONDARY,
			DANGER,
		}

		enum Behavior {
			DEFAULT,
			TOGGLE,
		}

		enum VisualStyle {
			STANDALONE,
			EMBEDDED,
		}

		enum Reason {
			CLICK,
			KEY_UP,
		}

		enum I18N {
			ABORT,
			CANCEL,
			CLOSE,
			COLLAPSE,
			EXPAND,
			FILL_DOWN,
			MAXIMIZE,
			MINIMIZE,
			OK,
			SEARCH,
			YES,
			NO,
		}

	}

	class CachedDataProvider {
		constructor(options?: Self.CachedDataProvider.Options);

		load(query: any): globalThis.Promise<any>;

	}

	namespace CachedDataProvider {
		interface Options {
			getData?: (test: string) => globalThis.Array<any>;

		}

	}

	export class Calendar extends PackageCore.Component {
		constructor(options?: Self.Calendar.Options);

		selectedDate: (PackageCore.Date | null);

		rangeStart: (PackageCore.Date | null);

		rangeEnd: (PackageCore.Date | null);

		viewDate: PackageCore.Date;

		viewType: Self.Calendar.ViewType;

		baseViewType: Self.Calendar.ViewType;

		today: PackageCore.Date;

		numberOfViews: number;

		startDate: (PackageCore.Date | null);

		endDate: (PackageCore.Date | null);

		firstDayOfWeek: number;

		wheelScrollEnabled: boolean;

		activeDescendant: (PackageCore.Component | null);

		setSelectedDate(date: (PackageCore.Date | null), options?: {updateView?: boolean; reason?: string}): void;

		setRangeStart(date: (PackageCore.Date | null), options?: {reason?: string}): boolean;

		setRangeEnd(date: (PackageCore.Date | null), options?: {reason?: string}): boolean;

		setDateRange(options: {start?: (PackageCore.Date | null); end?: (PackageCore.Date | null)}): void;

		setViewDate(date: PackageCore.Date): void;

		setViewType(type: Self.Calendar.ViewType): void;

		navigate(navigationDirection: Self.Calendar.NavigationDirection): void;

		isDateSelected(date: PackageCore.Date): boolean;

		isDateSelectable(date: PackageCore.Date): boolean;

		isBeforeStart(date: PackageCore.Date): boolean;

		isAfterEnd(date: PackageCore.Date): boolean;

		isInAllowedRange(date: PackageCore.Date): boolean;

		isDateEnabled(date: PackageCore.Date): boolean;

		isRangeInside(date: PackageCore.Date): boolean;

		isRangeEnd(date: PackageCore.Date): boolean;

		isRangeSelectable(date: PackageCore.Date): boolean;

		private _coerceDateRestrictions(date: PackageCore.Date, direction?: number): (PackageCore.Date | null);

		static Event: Self.Calendar.EventTypes;

	}

	export namespace Calendar {
		interface Options extends PackageCore.Component.Options {
			ariaFormat?: string;

			ariaLabel?: string;

			baseViewType?: Self.Calendar.ViewType;

			decadeView?: Self.CalendarDecadeView.Options;

			endDate?: (PackageCore.Date | null);

			firstDayOfWeek?: number;

			monthView?: Self.CalendarMonthView.Options;

			numberOfViews?: number;

			rangeEnd?: (PackageCore.Date | null);

			rangeStart?: (PackageCore.Date | null);

			selectedDate?: (PackageCore.Date | null);

			showNextMonth?: boolean;

			showPreviousMonth?: boolean;

			showWeekNumbers?: boolean;

			startDate?: (PackageCore.Date | null);

			titleMonthFormat?: string;

			titleYearFormat?: string;

			today?: (PackageCore.Date | null);

			viewDate?: (PackageCore.Date | null);

			viewType?: Self.Calendar.ViewType;

			wheelScrollEnabled?: boolean;

			yearView?: Self.CalendarYearView.Options;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			DATE_SELECTED: string;

			DATE_CLICKED: string;

			RANGE_START_SELECTED: string;

			RANGE_END_SELECTED: string;

		}

		export import Day = Self.CalendarDay;

		export import Month = Self.CalendarMonth;

		export import MonthView = Self.CalendarMonthView;

		export import Year = Self.CalendarYear;

		export import YearView = Self.CalendarYearView;

		export import DecadeView = Self.CalendarDecadeView;

		enum ViewType {
			MONTH,
			YEAR,
			DECADE,
		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
		}

		enum NavigationDirection {
			PREVIOUS_VIEW,
			PREVIOUS_ROW,
			PREVIOUS_ITEM,
			NEXT_VIEW,
			NEXT_ROW,
			NEXT_ITEM,
			FIRST_ITEM,
			LAST_ITEM,
		}

	}

	export class CalendarDay extends PackageCore.Component {
		constructor(options: Self.CalendarDay.Options);

		date: PackageCore.Date;

		selected: boolean;

		selectable: boolean;

		today: boolean;

		beforeStart: boolean;

		afterEnd: boolean;

		previousMonth: boolean;

		nextMonth: boolean;

		rangeStart: boolean;

		rangeInside: boolean;

		rangeEnd: boolean;

		customizeDay: (Self.CalendarDay.CustomizeCallback | null);

		static Event: Self.CalendarDay.EventTypes;

	}

	export namespace CalendarDay {
		interface Options extends PackageCore.Component.Options {
			date?: PackageCore.Date;

			ariaLabel?: string;

			selected?: boolean;

			selectable?: boolean;

			today?: boolean;

			beforeStart?: boolean;

			afterEnd?: boolean;

			previousMonth?: boolean;

			nextMonth?: boolean;

			rangeStart?: boolean;

			rangeInside?: boolean;

			rangeEnd?: boolean;

			customizeDay?: Self.CalendarDay.CustomizeCallback;

		}

		type CustomizeCallback = (args: {date: PackageCore.Date; day: Self.CalendarDay}) => void;

		interface EventTypes extends PackageCore.Component.EventTypes {
			CLICKED: string;

		}

		enum DayStatus {
			SELECTED,
			SELECTABLE,
			TODAY,
			BEFORE_START,
			AFTER_END,
			PREVIOUS_MONTH,
			NEXT_MONTH,
			RANGE_START,
			RANGE_INSIDE,
			RANGE_END,
		}

	}

	export class CalendarDecadeView extends PackageCore.Component {
		constructor(options: Self.CalendarDecadeView.Options);

		viewDate: PackageCore.Date;

		selectedDate: (PackageCore.Date | null);

		today: PackageCore.Date;

		startDate: (PackageCore.Date | null);

		endDate: (PackageCore.Date | null);

		ariaFormat: string;

		yearFormat: string;

		isYearDisabled: (((date: PackageCore.Date) => void) | null);

		customizeYear: (Self.CalendarYear.CustomizeCallback | null);

		setViewDate(date: PackageCore.Date): void;

		setSelectedDate(date: (PackageCore.Date | null), options: {reason?: string}): void;

		setDateRange(options: {start: (PackageCore.Date | null); end: (PackageCore.Date | null)}): void;

		yearForDate(date: PackageCore.Date): (Self.CalendarYear | null);

		isYearSelected(date: PackageCore.Date): boolean;

		isYearSelectable(date: PackageCore.Date): boolean;

		isBeforeStart(date: PackageCore.Date): boolean;

		isAfterEnd(date: PackageCore.Date): boolean;

		isInAllowedRange(date: PackageCore.Date): boolean;

		isYearEnabled(date: PackageCore.Date): boolean;

		static decadeStart(date: PackageCore.Date): void;

		static Event: Self.CalendarDecadeView.EventTypes;

	}

	export namespace CalendarDecadeView {
		interface Options extends PackageCore.Component.Options {
			viewDate: PackageCore.Date;

			ariaFormat: string;

			selectedDate?: PackageCore.Date;

			today?: PackageCore.Date;

			startDate?: PackageCore.Date;

			endDate?: PackageCore.Date;

			isYearDisabled?: (date: PackageCore.Date) => boolean;

			customizeYear?: Self.CalendarYear.CustomizeCallback;

			yearFormat?: string;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			YEAR_SELECTED: string;

			YEAR_CLICKED: string;

		}

	}

	export class CalendarMonth extends PackageCore.Component {
		constructor(options: Self.CalendarMonth.Options);

		date: PackageCore.Date;

		label: string;

		selected: boolean;

		selectable: boolean;

		today: boolean;

		beforeStart: boolean;

		afterEnd: boolean;

		customizeMonth: (Self.CalendarMonth.CustomizeCallback | null);

		setSelected(value: boolean): void;

		setSelectable(value: boolean): void;

		setBeforeStart(value: boolean): void;

		setAfterEnd(value: boolean): void;

		static Event: Self.CalendarMonth.EventTypes;

	}

	export namespace CalendarMonth {
		interface Options extends PackageCore.Component.Options {
			date: PackageCore.Date;

			label: string;

			selected: boolean;

			selectable: boolean;

			today: boolean;

			beforeStart: boolean;

			afterEnd: boolean;

			customizeMonth: Self.CalendarMonth.CustomizeCallback;

		}

		type CustomizeCallback = (args: {date: PackageCore.Date; month: Self.CalendarMonth}) => void;

		interface EventTypes extends PackageCore.Component.EventTypes {
			CLICKED: string;

		}

	}

	export class CalendarMonthView extends PackageCore.Component {
		constructor(options: Self.CalendarMonthView.Options);

		viewDate: PackageCore.Date;

		selectedDate: (PackageCore.Date | null);

		rangeStart: (PackageCore.Date | null);

		rangeEnd: (PackageCore.Date | null);

		today: PackageCore.Date;

		startDate: (PackageCore.Date | null);

		endDate: (PackageCore.Date | null);

		dayLabels: globalThis.Array<any>;

		showPreviousMonth: boolean;

		showNextMonth: boolean;

		showWeekNumbers: boolean;

		firstDayOfWeek: number;

		ariaFormatter: (((date: PackageCore.Date) => string) | null);

		customizeDay: (Self.CalendarDay.CustomizeCallback | null);

		isDayDisabled: (((date: PackageCore.Date) => boolean) | null);

		setViewDate(date: PackageCore.Date): void;

		setSelectedDate(date: (PackageCore.Date | null), options: {reason?: string}): void;

		setRangeStart(date: (PackageCore.Date | null)): void;

		setRangeEnd(date: (PackageCore.Date | null)): void;

		setDateRange(options: {start?: (PackageCore.Date | null); end?: (PackageCore.Date | null)}): void;

		dayForDate(date: PackageCore.Date): (Self.CalendarDay | null);

		isDaySelected(date: PackageCore.Date): boolean;

		isDaySelectable(date: PackageCore.Date): boolean;

		isBeforeStart(date: PackageCore.Date): boolean;

		isAfterEnd(date: PackageCore.Date): boolean;

		isInAllowedRange(date: PackageCore.Date): boolean;

		isRangeStart(date: PackageCore.Date): boolean;

		isRangeInside(date: PackageCore.Date): boolean;

		isRangeEnd(date: PackageCore.Date): boolean;

		isRangeSelectable(date: PackageCore.Date): boolean;

		isDayEnabled(date: PackageCore.Date): boolean;

		static Event: Self.CalendarMonthView.EventTypes;

	}

	export namespace CalendarMonthView {
		interface Options extends PackageCore.Component.Options {
			viewDate: PackageCore.Date;

			selectedDate?: PackageCore.Date;

			today?: PackageCore.Date;

			rangeStart?: PackageCore.Date;

			rangeEnd?: PackageCore.Date;

			startDate?: PackageCore.Date;

			endDate?: PackageCore.Date;

			dayLabels: globalThis.Array<string>;

			firstDayOfWeek?: number;

			showWeekNumbers?: boolean;

			showPreviousMonth?: boolean;

			showNextMonth?: boolean;

			isDayDisabled?: (date: PackageCore.Date) => boolean;

			ariaFormatter?: (date: PackageCore.Date) => string;

			customizeDay?: Self.CalendarDay.CustomizeCallback;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			DAY_SELECTED: string;

			DAY_CLICKED: string;

		}

		enum I18N {
			WEEK,
		}

	}

	export class CalendarPicker extends Self.Picker {
		constructor(options: Self.CalendarPicker.Options);

		calendar: Self.Calendar;

		private _handleDateSelected(args: object, currentDate: PackageCore.Date, oldDate: PackageCore.Date, reason: string): void;

		private _handleDateClicked(args: {date: PackageCore.Date; viewType: Self.Calendar.ViewType}): void;

		private _setActiveDescendant(): void;

	}

	export namespace CalendarPicker {
		interface Options extends Self.Picker.Options {
			calendar?: (Self.Calendar | Self.Calendar.Options);

			closeOnSelection?: boolean;

			returnSingleValue?: boolean;

		}

	}

	export class CalendarYear extends PackageCore.Component {
		constructor(options: Self.CalendarYear.Options);

		date: PackageCore.Date;

		selected: boolean;

		selectable: boolean;

		today: boolean;

		beforeStart: boolean;

		afterEnd: boolean;

		yearFormat: string;

		customizeYear: Self.CalendarYear.CustomizeCallback;

		setSelected(value: boolean): void;

		setSelectable(value: boolean): void;

		setBeforeStart(value: boolean): void;

		setAfterEnd(value: boolean): void;

		static Event: Self.CalendarYear.EventTypes;

	}

	export namespace CalendarYear {
		interface Options extends PackageCore.Component.Options {
			date: PackageCore.Date;

			selected: boolean;

			selectable: boolean;

			today: boolean;

			beforeStart: boolean;

			afterEnd: boolean;

			yearFormat: string;

			customizeYear: Self.CalendarYear.CustomizeCallback;

		}

		type CustomizeCallback = (args: {date: PackageCore.Date; year: Self.CalendarYear}) => void;

		interface EventTypes extends PackageCore.Component.EventTypes {
			CLICKED: string;

		}

	}

	export class CalendarYearView extends PackageCore.Component {
		constructor(options: Self.CalendarYearView.Options);

		viewDate: PackageCore.Date;

		selectedDate: (PackageCore.Date | null);

		today: PackageCore.Date;

		startDate: (PackageCore.Date | null);

		endDate: (PackageCore.Date | null);

		monthLabels: globalThis.Array<any>;

		isMonthDisabled: (((date: PackageCore.Date) => boolean) | null);

		ariaFormatter: (((date: PackageCore.Date) => string) | null);

		customizeMonth: (Self.CalendarMonth.CustomizeCallback | null);

		setViewDate(date: PackageCore.Date): void;

		setSelectedDate(date: (PackageCore.Date | null), options: {reason?: string}): void;

		setDateRange(options: {start?: (PackageCore.Date | null); end?: (PackageCore.Date | null)}): void;

		monthForDate(date: PackageCore.Date): (Self.CalendarMonth | null);

		isMonthSelected(date: PackageCore.Date): boolean;

		isMonthSelectable(date: PackageCore.Date): boolean;

		isBeforeStart(date: PackageCore.Date): boolean;

		isAfterEnd(date: PackageCore.Date): boolean;

		isInRange(date: PackageCore.Date): boolean;

		isMonthEnabled(date: PackageCore.Date): boolean;

		static Event: Self.CalendarYearView.EventTypes;

	}

	export namespace CalendarYearView {
		interface Options extends PackageCore.Component.Options {
			viewDate: PackageCore.Date;

			selectedDate?: PackageCore.Date;

			today?: PackageCore.Date;

			startDate?: PackageCore.Date;

			endDate?: PackageCore.Date;

			monthLabels?: globalThis.Array<string>;

			isMonthDisabled?: (date: PackageCore.Date) => boolean;

			ariaFormatter?: (date: PackageCore.Date) => string;

			customizeMonth?: Self.CalendarMonth.CustomizeCallback;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			MONTH_SELECTED: string;

			MONTH_CLICKED: string;

		}

	}

	export class Card extends PackageCore.Component {
		constructor(options?: Self.Card.Options);

		action: ((() => void) | null);

		decorator: (PackageCore.Decorator | null);

		image: (Self.Image | null);

		imageSize: Self.Card.ImageSize;

		title: (string | null);

		text: (string | null);

		children: PackageCore.VDom.Children;

		tools: (PackageCore.Component | null);

		mode: Self.Card.Mode;

		draggable: boolean;

		contentGap: (Self.Card.GapSize | Self.Card.GapSizeObject | null);

		hasAction: boolean;

		hasImage: boolean;

		hasText: boolean;

		hasTitle: boolean;

		hasTools: boolean;

		bloom: boolean;

		bloomAnimation: boolean;

		setAction(action: ((() => void) | null)): void;

		setImage(image: (string | PackageCore.Url | Self.Image | null)): void;

		setTitle(title: (string | null)): void;

		setText(text: (string | null)): void;

		setTools(tools: (PackageCore.Component | null)): void;

		setMode(mode: Self.Card.Mode): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		/**
		 * @deprecated Use draggable property on Card
		 */
		static draggableDecorator(options: object): PackageCore.Decorator;

		/**
		 * @deprecated Wrap your component in Card
		 */
		static defaultDecorator(options?: PackageCore.Decorator.Options): PackageCore.Decorator;

		static metric(options: {title: (string | number | PackageCore.Translation); metric: (string | number | PackageCore.Translation); metadata?: (string | number | PackageCore.Translation); description?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element); toolbar?: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>); action?: () => void; cardOptions?: Self.Card.Options}): Self.Card;

		static Metric(props: {title: (string | number | PackageCore.Translation); metric: (string | number | PackageCore.Translation); metadata?: (string | number | PackageCore.Translation); children?: PackageCore.VDom.Children; toolbar?: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>); action?: () => void; cardOptions?: Self.Card.Options}): PackageCore.JSX.Element;

	}

	export namespace Card {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			decorator?: PackageCore.Decorator;

			image?: (string | PackageCore.Url | Self.Image);

			imageSize?: Self.Card.ImageSize;

			mode?: Self.Card.Mode;

			text?: string;

			title?: string;

			tools?: PackageCore.Component;

			action?: () => void;

			contentGap?: (Self.Card.GapSize | Self.Card.GapSizeObject);

			bloom?: boolean;

			bloomAnimation?: boolean;

		}

		interface ImageSize {
			aspectRatio?: number;

			height?: string;

			width?: string;

		}

		interface GapSizeObject {
			top?: Self.Card.GapSize;

			bottom?: Self.Card.GapSize;

			start?: Self.Card.GapSize;

			end?: Self.Card.GapSize;

			horizontal?: Self.Card.GapSize;

			vertical?: Self.Card.GapSize;

		}

		export import GapSize = Self.GapSize;

		export import Decorator = PackageCore.Decorator;

		enum Mode {
			VERTICAL,
			HORIZONTAL,
		}

	}

	export class Carousel extends PackageCore.Component {
		constructor(options?: Self.Carousel.Options);

		autoplay: boolean;

		delimiterIcon: Self.Carousel.DelimiterIcon;

		delimiterSize: Self.Carousel.DelimiterSize;

		interval: number;

		currentIndex: number;

		isPlaying: boolean;

		delimiterBackgroundTransparency: Self.Carousel.DelimiterBackgroundTransparency;

		showArrows: Self.Carousel.ShowArrows;

		showControlButton: Self.Carousel.ShowControlButton;

		buttonsType: Self.Carousel.ButtonsType;

		items: globalThis.Array<any>;

		showDelimiters: boolean;

		children: PackageCore.VDom.Children;

		animation: Self.Carousel.Animation;

		infinite: boolean;

		private renderItems(): void;

		private renderItem(): void;

		static getStyles(): void;

	}

	export namespace Carousel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			autoplay?: boolean;

			delimiterIcon?: Self.Carousel.DelimiterIcon;

			delimiterSize?: Self.Carousel.DelimiterSize;

			delimiterBackgroundTransparency?: Self.Carousel.DelimiterBackgroundTransparency;

			showDelimiters?: Self.Carousel.ShowDelimiters;

			interval?: number;

			showArrows?: Self.Carousel.ShowArrows;

			showControlButton?: Self.Carousel.ShowControlButton;

			buttonType?: Self.Carousel.ButtonsType;

			animation?: Self.Carousel.Animation;

			infinite?: boolean;

		}

		export import DelimiterIcon = Self.DelimiterConstant.Icon;

		export import DelimiterSize = Self.DelimiterConstant.Size;

		export import DelimiterBackgroundTransparency = Self.CarouselConstants.BackgroundTransparency;

		export import ShowArrows = Self.CarouselConstants.ShowArrows;

		export import ShowControlButton = Self.CarouselConstants.ShowArrows;

		export import ShowDelimiters = Self.CarouselConstants.ShowArrows;

		export import ButtonsType = Self.CarouselConstants.ButtonsType;

		export import Animation = Self.CarouselConstants.Animation;

		export import ButtonName = Self.CarouselConstants.ButtonName;

		export import I18N = Self.CarouselConstants.I18n;

	}

	namespace CarouselConstants {
		enum BackgroundTransparency {
			FULL,
			HIGH,
			MEDIUM,
			LOW,
		}

		enum ShowArrows {
			ALWAYS,
			HOVER,
			HIDDEN,
		}

		enum ButtonsType {
			DEFAULT,
			EMBEDDED,
		}

		enum Animation {
			NONE,
			SLIDE,
			FADE,
		}

		enum ButtonName {
			PREVIOUS,
			NEXT,
			AUTOPLAY,
		}

		enum I18n {
			GO_PREVIOUS,
			GO_NEXT,
			START_PLAY,
			PAUSE_PLAY,
		}

	}

	export class CarouselItem {
		static JsxComponent(props?: {children?: PackageCore.VDom.Children; currentIndex?: any; key?: any; animation?: Self.CarouselConstants.Animation}): PackageCore.JSX.Element;

	}

	export namespace CarouselItem {
	}

	export class CellField extends PackageCore.Component {
		constructor(options?: Self.CellField.Options);

		cell: Self.GridCell;

		value: any;

		editable: boolean;

		mandatory: boolean;

		size: Self.Field.Size;

		orientation: Self.Field.Orientation;

		offset: boolean;

		assistiveContent: (PackageCore.Component | PackageCore.JSX.Element);

		inline: boolean;

		fieldLevelHelp: (Self.Field.FieldLevelHelpCallback | Self.HelpService.FieldLevelHelpOptions | null);

		activate(): void;

		acceptChanges(): void;

		discardChanges(): void;

		setEditable(value: boolean): void;

	}

	export namespace CellField {
		interface Options extends PackageCore.Component.Options {
			cell: Self.GridCell;

			size?: Self.Field.Size;

			orientation?: Self.Field.Orientation;

			offset?: boolean;

			mandatory?: boolean;

			fieldLevelHelp?: (Self.Field.FieldLevelHelpCallback | Self.HelpService.FieldLevelHelpOptions);

			assistiveContent?: PackageCore.Component;

			acceptChangesOnFocusOut?: boolean;

			inline?: boolean;

		}

		export import Size = Self.Field.Size;

	}

	export class Chart extends PackageCore.Component {
		constructor(options?: Self.Chart.Options);

		definition: (object | null);

		highlightFunction: (((data: Self.Chart.PointData) => boolean) | null);

		legend: boolean;

		title: (null | string | number | PackageCore.Translation);

		pointTooltip: Self.Chart.Tooltip;

		type: Self.Chart.Type;

		series: globalThis.Array<Self.Chart.Series>;

		stacking: (Self.Chart.Stacking | null);

		subtitle: (null | string | number | PackageCore.Translation);

		xAxis: (Self.Chart.Axis | globalThis.Array<Self.Chart.Axis>);

		yAxis: (Self.Chart.Axis | globalThis.Array<Self.Chart.Axis>);

		update(definition: object): void;

		withRawHandle(callback: (chart: any) => void): void;

		redraw(): void;

	}

	export namespace Chart {
		interface PointData {
			x?: number;

			y?: number;

		}

		interface TooltipData {
			seriesName?: string;

			x?: number;

			y?: number;

		}

		interface Tooltip {
			enabled?: boolean;

			formatter?: (data: Self.Chart.TooltipData) => Self.Chart.TooltipData;

		}

		interface Label {
			formatter?: (label: string) => string;

		}

		interface PlotLine {
			value?: number;

			text?: (null | string | number | PackageCore.Translation);

		}

		interface Axis {
			title?: (null | string | number | PackageCore.Translation);

			categories?: (globalThis.Array<string> | globalThis.Array<number>);

			min?: number;

			max?: number;

			opposite?: boolean;

			label?: Self.Chart.Label;

			plotLines?: globalThis.Array<Self.Chart.PlotLine>;

		}

		interface Series {
			name?: (null | string | number | PackageCore.Translation);

			data?: globalThis.Array<number>;

			type?: Self.Chart.Type;

			connectNulls?: boolean;

			dataLabels?: boolean;

			yAxis?: number;

			xAxis?: number;

			stack?: string;

			lineType?: Self.Chart.SeriesLineType;

			symbol?: Self.Chart.SeriesSymbol;

			highlightFunction?: (data: Self.Chart.PointData) => boolean;

		}

		interface Options extends PackageCore.Component.Options {
			type?: Self.Chart.Type;

			title?: (null | string | number | PackageCore.Translation);

			subtitle?: (null | string | number | PackageCore.Translation);

			xAxis?: (Self.Chart.Axis | globalThis.Array<Self.Chart.Axis>);

			yAxis?: (Self.Chart.Axis | globalThis.Array<Self.Chart.Axis>);

			series?: globalThis.Array<Self.Chart.Series>;

			legend?: boolean;

			stacking?: Self.Chart.Stacking;

			pointTooltip?: Self.Chart.Tooltip;

			highlightFunction?: (data: Self.Chart.PointData) => boolean;

			definition?: object;

			modules?: globalThis.Array<Self.Chart.Module>;

		}

		enum Module {
			CORE,
			MORE,
			ACCESSIBILITY,
			ANNOTATIONS,
			ANNOTATIONS_ADVANCED,
			ARROW_SYMBOLS,
			BOOST,
			BOOST_CANVAS,
			BROKEN_AXIS,
			BULLET,
			COLORAXIS,
			CURRENT_DATE_INDICATOR,
			CYLINDER,
			DATA,
			DATAGROUPING,
			DEBUGGER,
			DEPENDENCY_WHEEL,
			DOTPLOT,
			DRAG_PANES,
			DRAGGABLE_POINTS,
			DRILLDOWN,
			DUMBBELL,
			EXPORT_DATA,
			EXPORTING,
			FULL_SCREEN,
			FUNNEL,
			FUNNEL3D,
			GANTT,
			GRID_AXIS,
			HEATMAP,
			HISTOGRAM_BELLCURVE,
			ITEM_SERIES,
			LOLLIPOP,
			MARKER_CLUSTERS,
			NETWORKGRAPH,
			NO_DATA_TO_DISPLAY,
			OFFLINE_EXPORTING,
			OLDIE,
			ORGANIZATION,
			OVERLAPPING_DATALABELS,
			PARALLEL_COORDINATES,
			PARETO,
			PATHFINDER,
			PATTERN_FILL,
			PRICE_INDICATOR,
			PYRAMID3D,
			SANKEY,
			SERIES_LABEL,
			SOLID_GAUGE,
			SONIFICATION,
			STATIC_SCALE,
			STOCK,
			STOCK_TOOLS,
			STREAMGRAPH,
			SUNBURST,
			TILEMAP,
			TIMELINE,
			TREEGRID,
			TREEMAP,
			VARIABLE_PIE,
			VARIWIDE,
			VECTOR,
			VENN,
			WINDBARB,
			WORDCLOUD,
			XRANGE,
		}

		enum Type {
			AREA,
			BAR,
			COLUMN,
			LINE,
			SPLINE,
		}

		enum Stacking {
			NORMAL,
			PERCENT,
		}

		enum SeriesSymbol {
			CIRCLE,
			SQUARE,
			DIAMOND,
			TRIANGLE,
			TRIANGLE_DOWN,
		}

		enum SeriesLineType {
			SOLID,
			DASH,
		}

		enum Color {
			ORANGE,
			PINK,
			PURPLE,
			BLUE_LIGHT,
			AZURE,
			BLUE,
			RED,
			BROWN,
			GREEN,
			GREEN_MOSS,
			YELLOW,
			BLACK,
		}

		enum ColorIndex {
		}

	}

	class ChartHandle {
	}

	namespace ChartHandle {
	}

	class ChartManager {
	}

	namespace ChartManager {
	}

	export class ChartPortlet extends PackageCore.Component {
		constructor(options?: Self.ChartPortlet.Options);

	}

	export namespace ChartPortlet {
		interface Options extends PackageCore.Component.Options {
		}

	}

	export class CheckBox extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.CheckBox.Options);

		label: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element | null);

		labelPosition: Self.CheckBox.LabelPosition;

		value: (boolean | null);

		defined: boolean;

		clickableLabel: boolean;

		emptyLabel: boolean;

		readOnly: boolean;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		empty: boolean;

		mandatory: boolean;

		nextValue: (Self.CheckBox.NextValueProvider | null);

		action: (Self.CheckBox.ActionCallback | null);

		setValue(value: (boolean | null), options?: {reason?: string}): void;

		setLabel(label: string): void;

		setLabelPosition(position: Self.CheckBox.LabelPosition): void;

		setReadOnly(value: boolean): void;

		toggle(options?: {reason?: string}): void;

		static Event: Self.CheckBox.EventTypes;

	}

	export namespace CheckBox {
		interface Options extends PackageCore.Component.Options {
			clickableLabel?: boolean;

			label?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			labelPosition?: Self.CheckBox.LabelPosition;

			readOnly?: boolean;

			value?: (boolean | null);

			nextValue?: Self.CheckBox.NextValueProvider;

			mandatory?: boolean;

			action?: Self.CheckBox.ActionCallback;

		}

		type ActionCallback = (args: Self.CheckBox.ActionArgs, sender: Self.CheckBox) => void;

		interface ActionArgs {
			value: (boolean | null);

			previousValue: (boolean | null);

			reason: string;

		}

		type NextValueProvider = (value: (boolean | null)) => (boolean | null);

		interface EventTypes extends PackageCore.Component.EventTypes {
			TOGGLED: string;

		}

		export import Group = Self.CheckBoxGroup;

		export import Direction = Self.CheckBoxGroup.Direction;

		enum VisualStyle {
			CHECK,
		}

		enum LabelPosition {
			LEFT,
			RIGHT,
			ABOVE,
			BELOW,
		}

		enum Reason {
			CLICK,
			KEYPRESS,
		}

	}

	export class CheckBoxCell extends Self.GridCell {
		constructor(options?: object);

		checkBox: (Self.CheckBox | null);

		widgetOptions: (Self.CheckBox.Options | Self.GridCell.WidgetOptionsCallback<Self.CheckBox.Options>);

	}

	export namespace CheckBoxCell {
	}

	export class CheckBoxColumn extends Self.GridColumn {
		constructor(options: Self.CheckBoxColumn.Options);

		widgetOptions: (Self.CheckBox.Options | Self.GridColumn.WidgetOptionsCallback<Self.CheckBox.Options> | null);

	}

	export namespace CheckBoxColumn {
		interface Options extends Self.GridColumn.Options {
			widgetOptions?: (Self.CheckBox.Options | Self.GridColumn.WidgetOptionsCallback<Self.CheckBox.Options>);

		}

		export import Cell = Self.CheckBoxCell;

	}

	export class CheckBoxGroup extends PackageCore.Component {
		constructor(options?: Self.CheckBoxGroup.Options);

		content: PackageCore.Component;

		setContent(content: PackageCore.Component): void;

		children: PackageCore.VDom.Children;

		static getStyles(): void;

	}

	export namespace CheckBoxGroup {
		interface Options extends PackageCore.Component.Options {
			content?: PackageCore.Component;

			legend?: string;

			direction?: Self.CheckBoxGroup.Direction;

		}

		enum Direction {
			COLUMN,
			ROW,
		}

	}

	export class CheckBoxPicker extends Self.Picker {
		constructor(options?: Self.CheckBoxPicker.Options);

		checkBox: Self.CheckBox;

		private _handleSelectionChanged(args: Self.CheckBox.ActionArgs & {reason: string}): void;

	}

	export namespace CheckBoxPicker {
		interface Options extends PackageCore.Component.Options {
			checkBoxOptions: Self.CheckBox.Options;

		}

	}

	export class Code extends PackageCore.Component {
		constructor(options?: Self.Code.Options);

		children: PackageCore.VDom.Children;

		editable: boolean;

		content: string;

		setContent(content: string, options?: {reason?: string}): void;

		insertContent(content: string): void;

		static editor(options: Self.Code.Options): Self.Code;

		static Event: Self.Code.EventTypes;

	}

	export namespace Code {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: string;

			language?: Self.Code.Language;

			display?: Self.Code.Display;

			background?: Self.Code.Background;

			highlight?: boolean;

			editable?: boolean;

			showLIneNumbers?: boolean;

			lineWrapping?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			CONTENT_CHANGED: symbol;

		}

		enum Language {
			TEXT,
			JAVASCRIPT,
			CSS,
			HTML,
			JAVA,
		}

		enum Background {
			DEFAULT,
			THEME,
			SUCCESS,
			WARNING,
			ERROR,
			INFO,
		}

		enum Display {
			BLOCK,
			INLINE,
		}

		enum Reason {
			INPUT,
		}

	}

	export class ColorCanvas extends PackageCore.Component {
		constructor(options?: Self.ColorCanvas.Options);

		color: (PackageCore.Color | PackageCore.Color.HEX | null);

		mode: Self.ColorCanvas.Mode;

		size: Self.ColorCanvas.Size;

		withAlpha: boolean;

		setColor(hexOrColor: (PackageCore.Color | PackageCore.Color.HEX | null), args: {reason?: symbol}): void;

		setSize(newSize: Self.ColorCanvas.Size): void;

		setMode(newMode: Self.ColorCanvas.Mode): void;

		setWithAlpha(visible: boolean): void;

		private parseSize(): object;

		private getCurrentColor(): PackageCore.Color;

		private drawCanvas(): void;

		private drawIndicator(x: number, y: number): void;

		private drawSquareCanvas(context: object): void;

		private drawTriangleCanvas(context: object): void;

		private drawRainbowCanvas(context: object): void;

		private generateRainbowCanvasImageData(context: object): ImageData;

		private drawWheelCanvas(context: object): void;

		private generateWheelCanvasImageData(context: object): ImageData;

		private getIndicatorPosition(): (object | null);

		private getColorFromSquareCanvasPosition(x: number, y: number): PackageCore.Color;

		private getSquareCanvasIndicatorPosition(saturation: number, value: number): object;

		private getColorFromTriangleCanvasPosition(x: number, y: number): PackageCore.Color;

		private getTriangleCanvasIndicatorPosition(saturation: number, value: number): {x: number; y: number};

		private getColorFromRainbowCanvasPosition(x: number, y: number): PackageCore.Color;

		private getRainbowCanvasIndicatorPosition(hue: number, saturation: number): object;

		private getColorFromWheelCanvasPosition(x: number, y: number): PackageCore.Color;

		private getWheelCanvasIndicatorPosition(hue: number, saturation: number): object;

		private coordinatesToPolar(x: number, y: number, cX?: number, cY?: number): object;

		private radiansToDegrees(rad: number): number;

		private degreesToRadians(deg: number): number;

		private roundFloat(float: number): number;

		private limitValue(value: number, min: number, max: number): number;

		private isPointInTriangle(x: number, y: number): boolean;

		private handleClick(message: {position: {element: {x: number; y: number}}}, result: object): void;

		private createCanvas(): PackageCore.JSX.Element;

		private createSlider(): object;

		private createAlphaSlider(): object;

		static Event: Self.ColorCanvas.EventTypes;

	}

	export namespace ColorCanvas {
		interface Options extends PackageCore.Component.Options {
			color?: (PackageCore.Color | PackageCore.Color.HEX | null);

			mode?: Self.ColorCanvas.Mode;

			size?: Self.ColorCanvas.Size;

			withAlpha?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_COLOR_CHANGED: symbol;

		}

		enum Mode {
			SQUARE,
			TRIANGLE,
			WHEEL,
			RAINBOW,
			GRAYSCALE,
		}

		enum Reason {
			CALL,
			COLOR_SELECTED,
			UPDATE,
		}

		enum Source {
			CANVAS,
			GRAYSCALE_SLIDER,
			HUE_SLIDER,
			VALUE_SLIDER,
			ALPHA_SLIDER,
		}

		enum Size {
			SMALL,
			MEDIUM,
			LARGE,
		}

	}

	enum ColorComparator {
	}

	export class ColorModifier extends PackageCore.Component {
		constructor(options?: Self.ColorModifier.Options);

		color: (PackageCore.Color.HEX | PackageCore.Color | null);

		models: globalThis.Array<Self.ColorModifier.Model>;

		showTextBoxes: boolean;

		showSliders: boolean;

		setColor(value: (PackageCore.Color.HEX | PackageCore.Color | null), args?: {reason?: symbol; source?: any}): void;

		setModels(models: globalThis.Array<Self.ColorModifier.Model>): void;

		setTextBoxesVisibility(visibility: boolean): void;

		setSlidersVisibility(visibility: boolean): void;

		private createHexModifier(): Self.GridPanel;

		private handleHexChannelChange(_: any, options: {text: (string | null)}): void;

		private handleColorChannelChange(options: object): (PackageCore.Color | null);

		private createRgbModifier(): object;

		private createRgbChannelModifier(colorChannel: string, value: (string | null), text: string): object;

		private handleRgbChannelChange(colorChannel: string, newValue: (string | null)): (PackageCore.Color | null);

		private createCmykModifier(): object;

		private createCmykChannelModifier(colorChannel: string, value: (string | null), text: string): object;

		private handleCmykChannelChange(colorChannel: string, newValue: (string | null)): (PackageCore.Color | null);

		private createHslModifier(): object;

		private createHslChannelModifier(colorChannel: string, value: (string | null), text: string): object;

		private handleHslChannelChange(colorChannel: string, newValue: (string | null)): (PackageCore.Color | null);

		private createHsvModifier(): object;

		private createHsvChannelModifier(colorChannel: string, value: (string | null), text: string): object;

		private handleHsvChannelChange(colorChannel: string, newValue: (string | null)): (PackageCore.Color | null);

		private createHwbModifier(): object;

		private createHwbChannelModifier(colorChannel: string, value: (string | null), text: string): object;

		private handleHwbChannelChange(colorChannel: string, newValue: (string | null)): (PackageCore.Color | null);

		private createGrayscaleModifier(): object;

		private createAlphaModifier(): object;

		private createLabel(text: string): Self.Text;

		private createLabelId(model: string, channel: (string | null)): string;

		private createByteChannelTextBox(value: (string | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string): Self.TextBox;

		private createDegreesChannelTextBox(value: (string | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string): Self.TextBox;

		private createIntegerChannelTextBox(value: (string | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string, maximum: number): Self.TextBox;

		private createFloatChannelTextBox(value: (string | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string): Self.TextBox;

		private createHexTextBox(value: (string | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string): Self.TextBox;

		private createTextBox(value: (string | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, type: Self.ColorModifier.TextBoxType, textValidator: Self.TextBox.TextValidatorCallback, keyValidator: Self.TextBox.KeyValidatorCallback, revertHandler: (((textBox: Self.TextBox) => void) | null), labelId: string): Self.TextBox;

		private createByteChannelSlider(value: (number | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string): Self.Slider;

		private createDegreesChannelSlider(value: (number | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string): Self.Slider;

		private createFloatChannelSlider(value: (number | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string): Self.Slider;

		private createSlider(value: (number | null), handler: (modifier: Self.ColorModifier.Modifier, args: object) => void, labelId: string, items: Self.Slider.ValuesObject): Self.Slider;

		private handleIntegerChannelChanged(value: (string | null), type: Self.ColorModifier.Model, colorModifier: (modifier: number) => (PackageCore.Color | null), modifier: Self.ColorModifier.Modifier, args: object, maximum: object): void;

		private getNewValueFromIntegerModifier(modifier: Self.ColorModifier.Modifier, args: object): (number | null);

		private handleByteChannelChanged(type: Self.ColorModifier.Model, colorModifier: (modifier: number) => (PackageCore.Color | null), modifier: Self.ColorModifier.Modifier, args: object): void;

		private handleDegreesChannelChanged(type: Self.ColorModifier.Model, colorModifier: (modifier: number) => (PackageCore.Color | null), modifier: Self.ColorModifier.Modifier, args: object): void;

		private handleFloatChannelChanged(type: Self.ColorModifier.Model, colorModifier: (modifier: number) => (PackageCore.Color | null), modifier: Self.ColorModifier.Modifier, args: object): void;

		private getNewValueFromFloatModifier(modifier: Self.ColorModifier.Modifier, args: object): (number | null);

		private createModifierGrid(items: globalThis.Array<object>, channelCount: number): object;

		private createModel(model: Self.ColorModifier.Model): object;

		static Event: Self.ColorModifier.EventTypes;

	}

	export namespace ColorModifier {
		interface Options extends PackageCore.Component.Options {
			color?: (PackageCore.Color.HEX | PackageCore.Color);

			models?: (globalThis.Array<Self.ColorModifier.Model>);

			orientation?: Self.ColorModifier.Orientation;

			modifierOrientation?: Self.ColorModifier.Orientation;

			showTextBoxes?: boolean;

			showSliders?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_COLOR_CHANGED: symbol;

		}

		enum Reason {
			CALL,
			SLIDER_UPDATE,
			TEXT_BOX_UPDATE,
		}

		enum Model {
			HEX,
			RGB,
			CMYK,
			HSL,
			HSV,
			HWB,
			GRAYSCALE,
			ALPHA,
		}

		enum TextBoxType {
			HEX,
			INTEGER,
			FLOAT,
		}

		enum Orientation {
			HORIZONTAL,
			VERTICAL,
		}

		enum Modifier {
			SLIDER,
			TEXTBOX,
		}

	}

	export class ColorPalette extends PackageCore.Component {
		constructor(options?: Self.ColorPalette.Options);

		selectedColor: Self.ColorPalette.ColorValue;

		palettes: globalThis.Array<object>;

		palettesPanel: Self.AccordionPanel;

		setSelectedColor(color: Self.ColorPalette.ColorValue, args: {reason?: symbol}): void;

		private parsePalettes(palettes: globalThis.Array<any>): globalThis.Array<Self.ColorPalette.PaletteConfig>;

		private createPalette(palette: Self.ColorPalette.PaletteConfig, paletteIndex: number): Self.StackPanel;

		private createColor(paletteIndex: number, colorIndex: number): Self.ColorPaletteBox;

		private createAddButton(paletteIndex: number): Self.Button;

		private getAddButtonTooltipContent(selectedColorInPalette: boolean): PackageCore.Translation;

		private handleColorSelected(args: {color: Self.ColorPalette.ColorValue; selected: boolean; reason: symbol}): void;

		private handleColorDeleted(paletteIndex: number, colorIndex: number, args: {reason: Self.ColorPaletteBox.Reason}): void;

		private colorIsInPalette(color: PackageCore.Color, palette: Self.ColorPalette.PaletteConfig): object;

		private handleAddButtonClicked(paletteIndex: number): void;

		private focusColorBoxByDistance(distance: number): boolean;

		static Event: Self.ColorPalette.EventTypes;

	}

	export namespace ColorPalette {
		type ColorType = (null | PackageCore.Color.HEX | PackageCore.Color);

		type ColorValue = (undefined | Self.ColorPalette.ColorType);

		interface PaletteConfig {
			label?: (number | string | PackageCore.Translation);

			addButton?: boolean;

			deletable?: boolean;

			colors?: globalThis.Array<Self.ColorPalette.ColorType>;

			expanded?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			COLOR_SELECTED: symbol;

			SELECTED_COLOR_CHANGED: symbol;

			PALETTES_CHANGED: symbol;

			PALETTE_EXPANDED: symbol;

		}

		interface Options extends PackageCore.Component.Options {
			palettes?: globalThis.Array<Self.ColorPalette.PaletteConfig>;

			selectedColor?: Self.ColorPalette.ColorValue;

		}

		enum Reason {
			CALL,
			COLOR_SELECTED,
			COLOR_ADDED,
			COLOR_DELETED,
			UPDATE,
		}

		enum I18n {
			ADD_BUTTON_ENABLED,
			ADD_BUTTON_DISABLED,
			ADD_BUTTON_NO_COLOR_SELECTED,
		}

		enum Palette {
			NEUTRAL,
			COLOR_500,
			COLOR_100,
		}

	}

	export class ColorPaletteBox extends PackageCore.Component {
		constructor(options?: Self.ColorPaletteBox.Options);

		color: (PackageCore.Color | PackageCore.Color.HEX | null);

		selected: boolean;

		selectable: boolean;

		deletable: boolean;

		size: number;

		setColor(color: (PackageCore.Color | PackageCore.Color.HEX | null), args: {reason?: symbol}): void;

		setSelected(selected: boolean, args: {reason?: symbol}): void;

		setDeletable(deletable: boolean): void;

		delete(): void;

		private createColorClass(): globalThis.Array<PackageCore.Style>;

		private handleActivated(options: {reason: any}): void;

		static Event: Self.ColorPaletteBox.EventTypes;

	}

	export namespace ColorPaletteBox {
		interface Options extends PackageCore.Component.Options {
			color?: (PackageCore.Color | PackageCore.Color.HEX | null);

			selected?: boolean;

			selectable?: boolean;

			deletable?: boolean;

			size?: number;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			COLOR_SELECTED: symbol;

			COLOR_DELETED: symbol;

			COLOR_CHANGED: symbol;

			COLOR_ACTIVATED: symbol;

		}

		enum Reason {
			ENTER,
			DELETE,
			CLICK,
			CONTEXT_MENU,
			CALL,
		}

		enum I18n {
			DELETE,
			NO_COLOR,
		}

	}

	export class ColorPicker extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.ColorPicker.Options);

		color: (PackageCore.Color | PackageCore.Color.HEX | null);

		mode: Self.ColorPicker.Mode;

		displayType: Self.ColorPicker.DisplayType;

		empty: boolean;

		mandatory: boolean;

		opened: boolean;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		size: Self.ColorPicker.Size;

		onColorChanged: (Self.ColorPicker.ColorChangedCallback | null);

		setColor(value: Self.ColorPalette.ColorValue, args: {reason?: Self.ColorPicker.Reason}): void;

		setMandatory(newValue: boolean): void;

		setOpened(): void;

		openColorSelectorPicker(): void;

		closeColorSelectorPicker(): void;

		toggleColorSelectorPicker(): void;

		private createTextBox(): Self.TextBox;

		private colorToText(): string;

		private handleTextBoxTextAccepted(args: {reason: symbol}): void;

		private createIcon(): Self.Image;

		private createColorBox(): Self.ColorPaletteBox;

		private handleToggleClicked(): void;

		private createColorSelectorPicker(): Self.ColorSelectorPicker;

		private handleColorSelectorPickerSelectionChanged(args: {selectedItems: (PackageCore.Color | PackageCore.Color.HEX | null); source: symbol; reason: symbol}): void;

		static default(args: {options?: Self.ColorPicker.Options; customColors?: globalThis.Array<(PackageCore.Color | PackageCore.Color.HEX)>; withNull?: boolean}): Self.ColorPicker;

		static Default(props: Self.ColorPicker.Options & {customColors?: globalThis.Array<(PackageCore.Color | PackageCore.Color.HEX)>; withNull?: boolean}): PackageCore.JSX.Element;

		static withoutCustomColors(args: {options?: Self.ColorPicker.Options; withNull?: boolean}): Self.ColorPicker;

		static WithoutCustomColors(props: Self.ColorPicker.Options & {withNull?: boolean}): PackageCore.JSX.Element;

		static onlyPalette(args: {options?: Self.ColorPicker.Options; withNull?: boolean}): Self.ColorPicker;

		static OnlyPalette(props: Self.ColorPicker.Options & {withNull?: boolean}): PackageCore.JSX.Element;

		static Event: Self.ColorPicker.EventTypes;

		static createDefaultPaletteOptions(customColors?: globalThis.Array<(PackageCore.Color | PackageCore.Color.HEX)>): Self.ColorPalette.Options;

		static createPaletteOnlyPaletteOptions(): Self.ColorPalette.Options;

	}

	export namespace ColorPicker {
		interface Options extends PackageCore.Component.Options {
			color?: (PackageCore.Color | PackageCore.Color.HEX | null);

			colorSelector?: Self.ColorSelector.Options;

			displayType?: Self.ColorPicker.DisplayType;

			mandatory?: boolean;

			mode?: Self.ColorPicker.Mode;

			palettes?: globalThis.Array<Self.ColorPalette.PaletteConfig>;

			size?: Self.ColorPicker.Size;

			onColorChanged?: Self.ColorPicker.ColorChangedCallback;

		}

		type ColorChangedCallback = (args: Self.ColorPicker.ColorChangedArgs, sender: Self.ColorPicker) => void;

		interface ColorChangedArgs {
			color: (PackageCore.Color | null);

			previousColor: (PackageCore.Color | null);

			reason: Self.ColorPicker.Reason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			COLOR_CHANGED: symbol;

		}

		enum DisplayType {
			INPUT,
			COLOR_SWATCH,
		}

		export import Mode = Self.ColorSelector.Mode;

		enum Reason {
			CALL,
			VALID_COLOR,
			INVALID_COLOR,
			TEXT_BOX,
		}

		enum VisualStyle {
			DEFAULT,
			REDWOOD_FIELD,
		}

		export import Palette = Self.ColorPalette.Palette;

		enum I18N {
			OPEN_SELECTION,
		}

		export import Size = Self.InputSize;

	}

	export class ColorSelector extends PackageCore.Component {
		constructor(options?: Self.ColorSelector.Options);

		color: (PackageCore.Color | PackageCore.Color.HEX | null);

		mode: Self.ColorSelector.Mode;

		collapseWithLastPalette: boolean;

		colorPalette: object;

		colorCanvas: object;

		colorModifier: object;

		colorPaletteComponent: Self.ColorPalette;

		colorCanvasComponent: Self.ColorCanvas;

		colorModifierComponent: Self.ColorModifier;

		onColorChanged: (Self.ColorSelector.ColorChangedCallback | null);

		setColor(value: (PackageCore.Color | PackageCore.Color.HEX | null), args: {reason?: string}): void;

		setMode(mode: Self.ColorSelector.Mode): void;

		setModifiersExpanded(expanded: boolean): void;

		private createColorPalette(): Self.ColorPalette;

		private createColorCanvas(): Self.ColorCanvas;

		private createColorModifier(): Self.ColorModifier;

		static createDefaultPaletteOptions(options?: (globalThis.Array<(PackageCore.Color | PackageCore.Color.HEX | null)> | {customColors: globalThis.Array<(PackageCore.Color | PackageCore.Color.HEX | null)>; withNull: boolean})): Self.ColorPalette.Options;

		static createPaletteOnlyPaletteOptions(options?: {withNull?: boolean}): Self.ColorPalette.Options;

		static Event: Self.ColorSelector.EventTypes;

	}

	export namespace ColorSelector {
		interface Options extends PackageCore.Component.Options {
			collapseWithLastPalette?: boolean;

			color?: (PackageCore.Color | PackageCore.Color.HEX | null);

			colorCanvas?: Self.ColorCanvas.Options;

			colorModifier?: Self.ColorModifier.Options;

			colorPalette?: Self.ColorPalette.Options;

			mode?: Self.ColorSelector.Mode;

			palettes?: globalThis.Array<Self.ColorPalette.PaletteConfig>;

			onColorChanged?: Self.ColorSelector.ColorChangedCallback;

		}

		type ColorChangedCallback = (args: Self.ColorSelector.ColorChangedArgs, sender: Self.ColorSelector) => void;

		interface ColorChangedArgs {
			color: (PackageCore.Color | null);

			previousColor: (PackageCore.Color | null);

			source: (Self.ColorSelector.Source | null);

			reason: (Self.ColorSelector.Reason | null);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			COLOR_SELECTED: symbol;

			SELECTED_COLOR_CHANGED: symbol;

			PALETTES_CHANGED: symbol;

		}

		enum Reason {
			CALL,
			COLOR_SELECTED,
			UPDATE,
		}

		enum Source {
			COLOR_PALETTE,
			COLOR_CANVAS,
			COLOR_MODIFIER,
		}

		enum Mode {
			PALETTE_ONLY,
			COMPLETE,
		}

		enum I18n {
			CUSTOM_COLORS,
			PREDEFINED_COLORS,
		}

		export import Canvas = Self.ColorCanvas;

		export import Palette = Self.ColorPalette;

		export import PaletteBox = Self.ColorPaletteBox;

		export import Modifier = Self.ColorModifier;

	}

	export class ColorSelectorPicker extends Self.Picker {
		constructor(options: Self.ColorSelectorPicker.Options);

		colorSelector: Self.ColorSelector;

		setColor(color: (PackageCore.Color | PackageCore.Color.HEX), options?: {modifiersExpanded: boolean; reason: symbol}): void;

		private _handleColorSelected(args: {selectedColor: PackageCore.Color; previousColor: PackageCore.Color; source: Self.ColorSelector.Source; reason: symbol}): void;

		private _handleSelectedColorChanged(args: Self.ColorSelector.ColorChangedArgs): void;

		private _handlePalettesChanged(args: object): void;

	}

	export namespace ColorSelectorPicker {
		interface Options extends Self.Picker.Options {
			colorSelector?: (Self.ColorSelector | Self.ColorSelector.Options);

		}

	}

	class ColumnHitMap {
	}

	namespace ColumnHitMap {
	}

	class ColumnResizer {
		constructor();

	}

	namespace ColumnResizer {
	}

	class ComponentParser {
		constructor();

		parseValue(value: {bundleId?: string; type?: string}): any;

	}

	namespace ComponentParser {
	}

	export class ContentPanel extends PackageCore.Component {
		constructor(options?: Self.ContentPanel.Options);

		content: (PackageCore.Component | PackageCore.JSX.Element | null);

		element: Self.ContentPanel.Element;

		horizontalAlignment: Self.ContentPanel.HorizontalAlignment;

		verticalAlignment: Self.ContentPanel.VerticalAlignment;

		outerGap: (Self.ContentPanel.GapSize | Self.ContentPanel.GapSizeObject);

		decorator: (PackageCore.Decorator | null);

		children: PackageCore.VDom.Children;

		setContent(content: (PackageCore.Component | null)): void;

		setHorizontalAlignment(value: Self.ContentPanel.HorizontalAlignment): void;

		setVerticalAlignment(value: Self.ContentPanel.VerticalAlignment): void;

		setOuterGap(value: Self.ContentPanel.GapSize): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

	}

	export namespace ContentPanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (PackageCore.Component | PackageCore.JSX.Element);

			decorator?: PackageCore.Decorator;

			horizontalAlignment?: Self.ContentPanel.HorizontalAlignment;

			outerGap?: (Self.ContentPanel.GapSize | Self.ContentPanel.GapSizeObject);

			verticalAlignment?: Self.ContentPanel.VerticalAlignment;

			element?: Self.ContentPanel.Element;

		}

		interface GapSizeObject {
			top?: Self.ContentPanel.GapSize;

			bottom?: Self.ContentPanel.GapSize;

			start?: Self.ContentPanel.GapSize;

			end?: Self.ContentPanel.GapSize;

			horizontal?: Self.ContentPanel.GapSize;

			vertical?: Self.ContentPanel.GapSize;

		}

		enum HorizontalAlignment {
			START,
			END,
			CENTER,
			STRETCH,
		}

		enum VerticalAlignment {
			START,
			END,
			CENTER,
			STRETCH,
		}

		export import GapSize = Self.GapSize;

		export import Decorator = PackageCore.Decorator;

		export import Element = PackageCore.Html.Element.Section;

	}

	export class ContextMenu {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options: Self.ContextMenu.Options);

		opened: boolean;

		menu: Self.Menu;

		window: Self.Window;

		owner: (PackageCore.Component | PackageCore.VDomRef);

		open(args?: object): void;

		close(reason?: string): void;

		static Event: Self.ContextMenu.EventTypes;

	}

	export namespace ContextMenu {
		interface Options {
			owner: (PackageCore.Component | PackageCore.VDomRef);

			items?: globalThis.Array<Self.MenuItem.ItemDefinition>;

			menu?: Self.Menu.Options;

			window?: Self.Window.Options;

			on?: PackageCore.EventSource.ListenerMap;

		}

		interface EventTypes {
			OPENED: string;

			CLOSED: string;

		}

	}

	export class Dashboard extends PackageCore.Component {
		constructor(options?: Self.Dashboard.Options);

		scroll(options: PackageCore.ScrollController.ScrollOptions): boolean;

	}

	export namespace Dashboard {
		type LayoutResponsive = Record<Self.Dashboard.Breakpoint, Self.Dashboard.LayoutItem>;

		interface LayoutItem {
			id: any;

			width: (number | Self.Dashboard.LayoutResponsiveSize);

			height: (number | Self.Dashboard.LayoutResponsiveSize);

		}

		type LayoutResponsiveSize = Record<Self.Dashboard.Breakpoint, number>;

		type LayoutFunction = (width: Self.Dashboard.Breakpoint) => globalThis.Array<Self.Dashboard.LayoutItem>;

		interface Portlet {
			id: any;

			type: any;

			content: any;

		}

		interface Options extends PackageCore.Component.Options {
			layout: (globalThis.Array<Self.Dashboard.LayoutItem> | Self.Dashboard.LayoutResponsive | Self.Dashboard.LayoutFunction);

			portlets: globalThis.Array<Self.Dashboard.Portlet>;

		}

		export import Breakpoint = Self.ResponsivePanel.Breakpoint;

	}

	export class DataGrid extends Self.DataSourceComponent {
		constructor(options?: Self.DataGrid.Options);

		columns: globalThis.Array<Self.GridColumn>;

		headerRows: globalThis.Array<Self.GridHeaderRow>;

		dataRows: globalThis.Array<Self.GridDataRow>;

		flatDataRows: globalThis.Array<Self.GridDataRow>;

		pageDataRows: globalThis.Array<Self.GridDataRow>;

		flatPageDataRows: globalThis.Array<Self.GridDataRow>;

		dirtyRows: globalThis.Array<Self.GridDataRow>;

		topRootColumn: Self.GridColumn;

		leftRootColumn: Self.GridColumn;

		leftColumns: globalThis.Array<Self.GridColumn>;

		bodyRootColumn: Self.GridColumn;

		bodyColumns: globalThis.Array<Self.GridColumn>;

		rightRootColumn: Self.GridColumn;

		rightColumns: globalThis.Array<Self.GridColumn>;

		sectionRootColumn: {left: Self.GridColumn; body: Self.GridColumn; right: Self.GridColumn; top: Self.GridColumn};

		showHeader: boolean;

		cursor: {cell: (Self.GridCell | null); row: (Self.GridRow | null); column: (Self.GridColumn | null)};

		cursorCell: (Self.GridCell | null);

		cursorRow: (Self.GridRow | null);

		rangeSelection: (Self.GridCellRange | null);

		columnStretch: boolean;

		resizableColumns: boolean;

		resizableRows: boolean;

		draggableColumns: boolean;

		draggableRows: boolean;

		editable: boolean;

		paging: boolean;

		pageSize: number;

		pageNumber: number;

		inputController: Self.GridInputController;

		inputMode: Self.DataGrid.InputMode;

		stickySegments: {left: boolean; right: boolean; header: boolean; footer: boolean};

		stickyScrollbars: {horizontal: boolean; vertical: boolean};

		virtualization: boolean;

		sortable: boolean;

		sortDirections: globalThis.Array<Self.DataGrid.ColumnSortDirection>;

		dataLoader: (Self.Loader | null);

		placeholder: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		actionBar: (PackageCore.Component | PackageCore.JSX.Element | null);

		actionBarHeight: (number | null);

		actionBarVisible: boolean;

		stickyActionBar: boolean;

		showStatusIcon: boolean;

		rowCursor: boolean;

		cellCursor: boolean;

		columnReorder: boolean;

		rowReorder: boolean;

		cursorVisibility: Self.DataGrid.CursorVisibility;

		bodyViewportSize: PackageCore.Scrollable.Size;

		bodyContentSize: PackageCore.Scrollable.Size;

		scrollOffset: {x: number; y: number};

		scrollability: PackageCore.Scrollable.Scrollability;

		highlightRowsOnHover: boolean;

		onSort: Self.DataGrid.SortCallback;

		addColumn(columnDefinition: (Self.DataGrid.ColumnDefinition | Self.GridColumn), options?: {index?: number; section?: Self.DataGrid.ColumnSection; parentColumn?: Self.GridColumn; reason?: string}): Self.GridColumn;

		removeColumn(columnId: (string | Self.GridColumn)): Self.GridColumn;

		moveColumn(columnId: (string | Self.GridColumn), options: {parentColumn?: Self.GridColumn; section?: Self.DataGrid.ColumnSection; index: number}): Self.GridColumn;

		getColumn(columnId: (string | Self.GridColumn)): (Self.GridColumn | null);

		clearColumns(): void;

		setColumns(columns: Self.DataGrid.ColumnConfiguration): void;

		setEditable(value: boolean): void;

		setSortable(value: boolean): void;

		setResizableColumns(value: boolean): void;

		setResizableRows(value: boolean): void;

		setDraggableColumns(value: boolean): void;

		setDraggableRows(value: boolean): void;

		setPaging(paging: boolean): void;

		setPageSize(pageSize: number): void;

		setPageNumber(pageNumber: number): void;

		setSortDirections(directions: globalThis.Array<Self.DataGrid.ColumnSortDirection>): void;

		setPlaceholder(placeholder: (string | PackageCore.Translation | PackageCore.Component)): void;

		setRowCursor(value: boolean): void;

		setCellCursor(value: boolean): void;

		setCursorVisibility(value: Self.DataGrid.CursorVisibility): void;

		createSyntheticRow(args?: Self.GridSyntheticRow.Options): Self.GridSyntheticRow;

		createSyntheticCell(args: Self.GridSyntheticCell.Options): Self.GridSyntheticCell;

		createDataCell(args: any): Self.GridCell;

		addSyntheticRow(row: Self.GridSyntheticRow, args: {masterRow?: Self.GridRow; section?: string; inside?: boolean; above?: boolean; order?: number}): Self.GridSyntheticRow;

		removeSyntheticRow(syntheticRow: Self.GridSyntheticRow): void;

		pinRow(row: Self.GridDataRow, section: Self.DataGrid.RowSection): void;

		moveCursorByOffset(args: {x?: number; y?: number; predicate?: (cell: Self.GridCell) => boolean; reason?: Self.DataGrid.CursorUpdateReason}): boolean;

		moveCursorToRow(row: Self.GridRow, options?: {reason?: string}): boolean;

		moveCursorToCell(cell: Self.GridCell, options?: {reason?: string}): boolean;

		setCursorCell(cell: Self.GridCell, args?: {scrollIntoView?: boolean; reason?: string}): boolean;

		resetCursor(args?: {reason?: string}): void;

		setRangeSelection(range: (Self.GridCellRange | null)): void;

		scrollTo(args: {cell?: Self.GridCell; column?: Self.GridColumn; row?: Self.GridRow; element?: Element}): void;

		autoSize(options?: {header?: boolean; body?: boolean; footer?: boolean; width?: boolean; height?: boolean}): void;

		autoSizeWidth(): void;

		autoSizeHeader(options: {width?: boolean; height?: object}): void;

		flushAutoSize(): void;

		stretchColumns(): void;

		rowForDataItem(dataItem: any): (Self.GridDataRow | null);

		cellForElement(element: Element): (Self.GridCell | null);

		cellForMessage(message: PackageCore.RoutedMessage): (Self.GridCell | null);

		refreshColumnCells(column: Self.GridColumn): void;

		reloadColumnCells(column: Self.GridColumn): void;

		visitColumns(callback: (column: Self.GridColumn) => (boolean | null)): void;

		visitRows(callback: (row: Self.GridRow) => void): void;

		visitSectionRows(section: Self.DataGrid.RowSection, callback: (row: Self.GridRow) => void): void;

		visitDataRows(callback: (row: Self.GridDataRow) => (boolean | null)): void;

		visitPageDataRows(callback: (row: Self.GridDataRow) => (boolean | null)): void;

		visitColumnCells(column: Self.GridColumn, callback: (cell: Self.GridCell) => void): void;

		visitColumnDataCells(column: Self.GridColumn, callback: (cell: Self.GridCell) => void): void;

		getPageDataRows(pageNumber: number): globalThis.Array<Self.GridDataRow>;

		findFirstCell(args: {predicate?: (cell: Self.GridCell) => boolean}): (Self.GridCell | null);

		findLastCell(args: {predicate?: (cell: Self.GridCell) => boolean}): (Self.GridCell | null);

		findCellByOffset(cell: Self.GridCell, args: {x?: number; y?: number; predicate?: (cell: Self.GridCell) => boolean}): (Self.GridCell | null);

		findNextCell(cell: Self.GridCell, args: {direction?: number; predicate?: (cell: Self.GridCell) => boolean}): (Self.GridCell | null);

		createOverlay(args: object): Self.GridOverlay;

		editCell(cell: Self.GridCell, activate: boolean, reason: Self.DataGrid.CursorUpdateReason): boolean;

		startEditing(cell: Self.GridCell, activate: boolean, reason: Self.DataGrid.CursorUpdateReason): void;

		closeEditing(focusGrid: boolean): void;

		acceptChanges(): void;

		discardChanges(): void;

		reload(): void;

		loadAll(): globalThis.Promise<any>;

		expandAll(): globalThis.Promise<any>;

		getRowSectionPhysicalSize(rowSection: Self.DataGrid.RowSection): number;

		getColumnSectionPhysicalSize(columnSection: Self.DataGrid.ColumnSection): number;

		protected createRowSet(): object;

		protected bindDataRow(args: {dataRow: Self.GridRow; dataStoreEntry: object}): void;

		private configureHeaderCells(overlapCells: globalThis.Map<any, any>, level: number, row: Self.GridRow, column: Self.GridColumn): Self.GridCell;

		private configureDataCells(row: Self.GridRow, column: Self.GridColumn): Self.GridCell;

		static Event: Self.DataGrid.EventTypes;

	}

	export namespace DataGrid {
		interface StretchStrategyOptions {
			ignoreMaxWidth?: boolean;

		}

		interface Options extends Self.DataSourceComponent.Options {
			actionBar?: (PackageCore.Component | PackageCore.JSX.Element);

			actionBarHeight?: number;

			actionBarVisible?: boolean;

			allowUnsort?: boolean;

			allowRangeSelection?: boolean;

			autoSize?: Self.DataGrid.SizingStrategy;

			autoSizeHeader?: boolean;

			bindingController?: Self.GridBindingController;

			cellCursor?: boolean;

			columnDragSource?: PackageCore.DataExchange.DragSourceProvider;

			columnReorder?: boolean;

			columns?: Self.DataGrid.ColumnConfiguration;

			columnStretch?: boolean;

			customizeHeaderRow?: Self.DataGrid.CustomizeHeaderRowCallback;

			customizeRow?: Self.DataGrid.CustomizeRowCallback;

			dataLoader?: (Self.Loader | null);

			dataRowHeight?: number;

			directWrite?: boolean;

			draggableColumns?: boolean;

			draggableRows?: boolean;

			editable?: boolean;

			headerContent?: Self.GridHeaderCell.ContentCallback;

			headerRowHeight?: number;

			inputController?: Self.GridInputController;

			editingMode?: Self.DataGrid.EditingMode;

			inputMode?: Self.DataGrid.InputMode;

			keepSelection?: boolean;

			maxViewportHeight?: number;

			maxViewportWidth?: number;

			multiColumnSort?: boolean;

			pageNumber?: number;

			pageSize?: number;

			paging?: boolean;

			placeholder?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			preload?: Self.DataGrid.Preload;

			resizableColumns?: boolean;

			resizableRows?: boolean;

			rowCursor?: boolean;

			highlightRowsOnHover?: boolean;

			rowDragSource?: PackageCore.DataExchange.DragSourceProvider;

			rowReorder?: boolean;

			showHeader?: boolean;

			showStatusIcon?: boolean;

			sortable?: boolean;

			stretchStrategy?: (((args: object) => void) | Self.DataGrid.StretchStrategyOptions);

			stripedRows?: boolean;

			virtualization?: boolean;

			defaultColumnOptions?: Partial<Self.GridColumn.Options>;

			cursorVisibility?: Self.DataGrid.CursorVisibility;

			beforeEditCell?: Self.GridSelectEditInputController.BeforeEditCellCallback;

			lockedLevels?: number;

			stickySegments?: Self.DataGrid.StickySegments;

			onSort?: Self.DataGrid.SortCallback;

		}

		type ColumnConfiguration = (globalThis.Array<Self.DataGrid.ColumnDefinition> | {left: globalThis.Array<Self.DataGrid.ColumnDefinition>; body: globalThis.Array<Self.DataGrid.ColumnDefinition>; right: globalThis.Array<Self.DataGrid.ColumnDefinition>});

		type SortCallback = (args: Self.DataGrid.SortArgs, sender: Self.DataGrid) => void;

		interface SortArgs {
			directions: globalThis.Array<Self.DataGrid.SortArg>;

			previousDirections: globalThis.Array<Self.DataGrid.SortArg>;

		}

		interface SortArg {
			column: Self.GridColumn;

			direction: Self.DataGrid.SortDirection;

		}

		type CustomizeHeaderRowCallback = (args: {index: number; row: Self.GridHeaderRow}) => void;

		type CustomizeRowCallback = (args: Self.DataGrid.CustomizeRowCallbackArgs) => void;

		interface CustomizeRowCallbackArgs {
			dataGrid: Self.DataGrid;

			row: Self.GridDataRow;

			dataItem: any;

			index: number;

			level: number;

		}

		type ColumnDefinition = (Self.ActionColumn.Options | Self.CheckBoxColumn.Options | Self.DatePickerColumn.Options | Self.DropdownColumn.Options | Self.GrabColumn.Options | Self.LinkColumn.Options | Self.MultiselectDropdownColumn.Options | Self.SelectionColumn.Options | Self.TemplatedColumn.Options | Self.TextAreaColumn.Options | Self.TextBoxColumn.Options | Self.TimePickerColumn.Options | Self.TreeColumn.Options);

		interface EventTypes extends Self.DataSourceComponent.EventTypes {
			ROW_UPDATE: string;

			COLUMN_UPDATE: string;

			CELL_UPDATE: string;

			ROW_SELECTION_CHANGED: string;

			CURSOR_UPDATED: string;

			SCROLLABILITY_CHANGED: string;

			SORT: string;

		}

		interface ColumnSortDirection {
			column: Self.GridColumn;

			direction: Self.DataGrid.SortDirection;

		}

		interface StickySegments {
			header: boolean;

			footer: boolean;

			left: boolean;

			right: boolean;

		}

		enum SizingStrategy {
			MANUAL,
			INITIAL_WIDTH,
		}

		export import RowSection = Self.GridConstants.RowSection;

		export import Row = Self.GridRow;

		export import HeaderRow = Self.GridMasterRow;

		export import MasterRow = Self.GridMasterRow;

		export import DataRow = Self.GridDataRow;

		export import SyntheticRow = Self.GridSyntheticRow;

		export import ColumnSection = Self.GridConstants.ColumnSection;

		export import ColumnType = Self.GridConstants.ColumnType;

		export import Column = Self.GridColumn;

		export import TextBoxColumn = Self.TextBoxColumn;

		export import TextAreaColumn = Self.TextAreaColumn;

		export import TreeColumn = Self.TreeColumn;

		export import DetailColumn = Self.TreeColumn;

		export import GrabColumn = Self.GrabColumn;

		export import CheckBoxColumn = Self.CheckBoxColumn;

		export import DropdownColumn = Self.DropdownColumn;

		export import MultiselectDropdownColumn = Self.MultiselectDropdownColumn;

		export import DatePickerColumn = Self.DatePickerColumn;

		export import TimePickerColumn = Self.TimePickerColumn;

		export import ActionColumn = Self.ActionColumn;

		export import TemplatedColumn = Self.TemplatedColumn;

		export import LinkColumn = Self.LinkColumn;

		export import SelectionColumn = Self.SelectionColumn;

		export import Cell = Self.GridCell;

		export import HeaderCell = Self.GridHeaderCell;

		export import SyntheticCell = Self.GridSyntheticCell;

		export import TextBoxCell = Self.TextBoxCell;

		export import TextAreaCell = Self.TextAreaCell;

		export import TreeCell = Self.TreeCell;

		export import GrabCell = Self.GrabCell;

		export import CheckBoxCell = Self.CheckBoxCell;

		export import DropdownCell = Self.DropdownCell;

		export import MultiselectDropdownCell = Self.MultiselectDropdownCell;

		export import DatePickerCell = Self.DatePickerCell;

		export import TimePickerCell = Self.TimePickerCell;

		export import ActionCell = Self.ActionCell;

		export import TemplatedCell = Self.TemplatedCell;

		export import LinkCell = Self.LinkCell;

		export import SelectionCell = Self.SelectionCell;

		export import DataExchange = Self.GridDataExchange;

		export import InputMode = Self.GridConstants.InputMode;

		enum EditingMode {
			CELL,
			ROW,
		}

		export import Selection = Self.GridSelection;

		export import SelectionStrategy = Self.GridSelectionStrategy;

		export import SingleSelection = Self.GridSingleSelection;

		export import SingleSelectionStrategy = Self.GridSingleSelectionStrategy;

		export import MultiSelection = Self.GridMultiSelection;

		export import MultiSelectionStrategy = Self.GridMultiSelectionStrategy;

		export import HelperButtonMode = Self.GridConstants.HelperButtonMode;

		export import SortDirection = Self.GridConstants.SortDirection;

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
		}

		enum RowUpdateReason {
			DATA_UNBIND,
			ITEM_ADDED,
			ITEM_REMOVED,
			ITEM_MOVED,
		}

		export import CursorUpdateReason = Self.GridConstants.CursorUpdateReason;

		enum SelectionUpdateReason {
			DATA_UNBIND,
			ROWS_REMOVED,
		}

		enum Preload {
			ALL,
			VISIBLE,
			NONE,
		}

		enum CursorVisibility {
			FOCUS,
			ALWAYS,
		}

		export import Reason = Self.DataSourceComponent.UnbindReason;

	}

	export abstract class DataSourceComponent extends PackageCore.Component {
		protected constructor(options?: Self.DataSourceComponent.Options);

		dataSource: PackageCore.DataSource;

		dataBound: boolean;

		bindingData: boolean;

		unbindingData: boolean;

		dataAccess: boolean;

		autoBind: boolean;

		showLoaderOnDataAccess: boolean;

		setDataSource(dataSource: (PackageCore.DataSource | null), options?: {reason?: string}): globalThis.Promise<any>;

		dataBind(): globalThis.Promise<any>;

		dataUnbind(): void;

		protected _onBindToDataSource(args: {dataSource: PackageCore.DataSource}): void;

		protected _onDataBound(args: {dataSource: PackageCore.DataSource}): void;

		protected _onUnbindFromDataSource(args: {dataSource: PackageCore.DataSource}): void;

		protected _onDataUnbound(args: {dataSource: PackageCore.DataSource}): void;

		protected _onDataSourceUpdated(update: {cause: PackageCore.DataSource.UpdateType; args: object}): void;

		protected _onDataAccessStarted(): void;

		protected _onDataAccessFinished(): void;

		static getValueMember(dataItem: object, valueMember: Self.DataSourceComponent.ValueMember): any;

		static getDisplayMember(dataItem: object, displayMember: Self.DataSourceComponent.DisplayMember): (PackageCore.Translation | string);

		static Event: Self.DataSourceComponent.EventTypes;

	}

	export namespace DataSourceComponent {
		interface Options extends PackageCore.Component.Options {
			showLoaderOnDataAccess?: boolean;

			autoBind?: boolean;

			dataSource?: PackageCore.DataSource;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			DATA_BOUND: string;

			DATA_UNBOUND: string;

			DATA_ACCESS_STARTED: string;

			DATA_ACCESS_FINISHED: string;

		}

		type DisplayMember = (string | Self.DataSourceComponent.DisplayMemberCallback);

		type ValueMember = (string | Self.DataSourceComponent.ValueMemberCallback);

		type DisplayMemberCallback = (dataItem: any) => any;

		type ValueMemberCallback = (dataItem: any) => any;

		enum UnbindReason {
			DATA_UNBIND,
			DISPOSE,
		}

	}

	export class DatePicker extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options: Self.DatePicker.Options);

		date: (PackageCore.Date | null);

		time: (PackageCore.Time | null);

		empty: boolean;

		mandatory: boolean;

		inputText: string;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		format: (string | null);

		formatter: (Self.DatePicker.FormatterCallback | null);

		parser: (Self.DatePicker.ParserCallback | null);

		startDate: (PackageCore.Date | null);

		endDate: (PackageCore.Date | null);

		viewDate: (PackageCore.Date | null);

		allowEmptyValue: boolean;

		comparator: (left: PackageCore.Date, right: PackageCore.Date) => number;

		datePickerOpened: boolean;

		timePickerOpened: boolean;

		calendar: Self.Calendar.Options;

		timePickerOptions: object;

		allowUserInput: boolean;

		firstDayOfWeek: number;

		showNextMonth: boolean;

		showPreviousMonth: boolean;

		showWeekNumbers: boolean;

		iconPosition: Self.DatePicker.IconPosition;

		placeholder: (string | null);

		size: Self.DatePicker.Size;

		onDateChanged: (Self.DatePicker.DateChangedCallback | null);

		acceptChanges(): void;

		setDate(date: (PackageCore.Date | null), options: {reason?: string; inputText?: string}): void;

		setInputText(text: string, options: {reason?: string; acceptChanges?: boolean}): void;

		setFormat(format: (string | null)): void;

		setFormatter(formatter: (((date: (PackageCore.Date | null)) => string) | null)): void;

		setParser(parser: (((text: string) => (PackageCore.Date | null)) | null)): void;

		setStartDate(date: (PackageCore.Date | null)): void;

		setEndDate(date: (PackageCore.Date | null)): void;

		setViewDate(date: (PackageCore.Date | null)): void;

		setAllowEmptyValue(value: boolean): void;

		openDatePicker(): boolean;

		closeDatePicker(): void;

		toggleDatePicker(): void;

		openTimePicker(): boolean;

		closeTimePicker(): void;

		toggleTimePicker(): void;

		selectAll(): void;

		dateEquals(left: (PackageCore.Date | null), right: (PackageCore.Date | null)): boolean;

		static Event: Self.DatePicker.EventTypes;

	}

	export namespace DatePicker {
		interface Options extends PackageCore.Component.Options {
			allowEmptyValue?: boolean;

			calendar?: Self.Calendar.Options;

			comparator?: Self.DatePicker.ComparatorCallback;

			validator?: Self.DatePicker.ValidatorCallback;

			date?: PackageCore.Date;

			datePickerType?: Self.Calendar.ViewType;

			endDate?: PackageCore.Date;

			firstDayOfWeek?: number;

			format?: string;

			formatter?: Self.DatePicker.FormatterCallback;

			iconPosition?: Self.DatePicker.IconPosition;

			parser?: Self.DatePicker.ParserCallback;

			placeholder?: (string | PackageCore.Translation);

			showNextMonth?: boolean;

			showPreviousMonth?: boolean;

			showWeekNumbers?: boolean;

			startDate?: PackageCore.Date;

			timeline?: object;

			withDatePicker?: boolean;

			withTimePicker?: boolean;

			mandatory?: boolean;

			allowUserInput?: boolean;

			timePickerOptions?: object;

			size?: Self.DatePicker.Size;

			onDateChanged?: Self.DatePicker.DateChangedCallback;

		}

		type DateChangedCallback = (args: Self.DatePicker.DateChangedArgs, sender: Self.DatePicker) => void;

		interface DateChangedArgs {
			date: (PackageCore.Date | null);

			previousDate: (PackageCore.Date | null);

			reason: Self.DatePicker.Reason;

		}

		type ComparatorCallback = (left: PackageCore.Date, right: PackageCore.Date) => number;

		type ValidatorCallback = (args: {empty: boolean; inputText: string; date: (PackageCore.Date | null)}) => void;

		type FormatterCallback = (date: (PackageCore.Date | null)) => string;

		type ParserCallback = (text: string) => (PackageCore.Date | null);

		interface EventTypes extends PackageCore.Component.EventTypes {
			DATE_CHANGED: string;

			INPUT_TEXT_CHANGED: string;

			INPUT_TEXT_ACCEPTED: string;

		}

		enum IconPosition {
			START,
			END,
		}

		enum Reason {
			AFTER,
			BEFORE,
			CLEAR,
			DATE_CHANGED,
			DATE_FORMATTED,
			DATE_PICKED,
			DISABLED,
			EMPTY,
			ENTER,
			INVALID_INPUT,
			PICKER_SELECTION_CHANGED,
			TEXT_CHANGED,
			TEXT_ACCEPTED,
			TIME_PICKED,
		}

		export import Size = Self.InputSize;

		enum I18N {
			OPEN_SELECTION,
		}

		export import DatePickerType = Self.Calendar.ViewType;

	}

	export class DatePickerCell extends Self.GridCell {
		constructor();

		format: string;

		formatter: (((data: (PackageCore.Date | null)) => string) | null);

		parser: (((text: string) => (PackageCore.Date | null)) | null);

		withTimePicker: boolean;

		datePicker: (Self.DatePicker | null);

		bindToText: boolean;

		widgetOptions: (Self.DatePicker.Options | Self.GridCell.WidgetOptionsCallback<Self.DatePicker.Options>);

	}

	export namespace DatePickerCell {
	}

	export class DatePickerColumn extends Self.GridColumn {
		constructor(options?: Self.DatePickerColumn.Options);

		format: (string | null);

		formatter: (Self.DatePicker.FormatterCallback | null);

		parser: (Self.DatePicker.ParserCallback | null);

		withTimePicker: boolean;

		bindToText: boolean;

		widgetOptions: (Self.DatePicker.Options | Self.GridColumn.WidgetOptionsCallback<Self.DatePicker.Options> | null);

		static defaultComparator(cell: Self.DatePickerCell, oldValue: (PackageCore.Date | string), newValue: (PackageCore.Date | string)): boolean;

	}

	export namespace DatePickerColumn {
		interface Options extends Self.GridColumn.Options {
			format?: string;

			formatter?: Self.DatePicker.FormatterCallback;

			parser?: Self.DatePicker.ParserCallback;

			withTimePicker?: boolean;

			bindToText?: boolean;

			widgetOptions?: (Self.DatePicker.Options | Self.GridColumn.WidgetOptionsCallback<Self.DatePicker.Options>);

		}

		export import Cell = Self.DatePickerCell;

	}

	export class DateRange extends PackageCore.Component {
		constructor(options?: Self.DateRange.Options);

		start: (Self.DatePicker | null);

		startRef: PackageCore.VDomRef;

		end: (Self.DatePicker | null);

		endRef: PackageCore.VDomRef;

		range: Self.DateRange.Range;

		rangeStart: (PackageCore.Date | null);

		rangeEnd: (PackageCore.Date | null);

		defaultInterval: (((date: PackageCore.Date) => PackageCore.Date) | null);

		inputOptions: Self.DatePicker.Options;

		startOptions: Self.DatePicker.Options;

		endOptions: Self.DatePicker.Options;

		onRangeChanged: (Self.DateRange.RangeChangedCallback | null);

		setRange(value: Self.DateRange.Range, options?: {reason?: string}): void;

		setRangeStart(startDate: (PackageCore.Date | null), options?: {reason?: string}): void;

		setRangeEnd(endDate: (PackageCore.Date | null), options?: {reason?: string}): void;

		static rangeEquals(left: (Self.DateRange.Range | null), right: (Self.DateRange.Range | null)): boolean;

		static Event: Self.DateRange.EventTypes;

	}

	export namespace DateRange {
		interface Options extends PackageCore.Component.Options {
			defaultInterval?: (date: PackageCore.Date) => PackageCore.Date;

			endOptions?: Self.DatePicker.Options;

			inputOptions?: Self.DatePicker.Options;

			range?: Self.DateRange.Range;

			startOptions?: Self.DatePicker.Options;

			startRef?: PackageCore.VDomRef;

			endRef?: PackageCore.VDomRef;

			onRangeChanged?: Self.DateRange.RangeChangedCallback;

		}

		interface Range {
			startDate: (PackageCore.Date | null);

			endDate: (PackageCore.Date | null);

		}

		type RangeChangedCallback = (args: Self.DateRange.RangeChangedArgs, sender: Self.DateRange) => void;

		interface RangeChangedArgs {
			range: (Self.DateRange.Range | null);

			previousRange: (Self.DateRange.Range | null);

			reason: Self.DateRange.Reason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			RANGE_CHANGED: string;

		}

		enum Reason {
			DATE_CHANGED,
			INTERVAL,
		}

		enum VisualStyle {
			DEFAULT,
			REDWOOD_FIELD,
		}

	}

	export class DateRangePicker extends Self.Picker {
		constructor(options: Self.DateRangePicker.Options);

		dateRange: Self.DateRange;

		private _handleRangeSelected(args: Self.DateRange.RangeChangedArgs): void;

	}

	export namespace DateRangePicker {
		interface Options extends Self.Picker.Options {
			dateRange?: Self.DateRange.Options;

		}

	}

	export class Delimiter extends PackageCore.Component {
		constructor(options?: Self.Delimiter.Options);

		icon: Self.Delimiter.Icon;

		size: Self.Delimiter.Size;

		selected: boolean;

		onClick: Function;

		index: number;

		static getStyles(): void;

	}

	export namespace Delimiter {
		interface Options extends PackageCore.Component.Options {
			icon?: Self.Delimiter.Icon;

			size?: Self.Delimiter.Size;

			selected?: boolean;

			onClick: Function;

			index?: number;

		}

		export import Icon = Self.DelimiterConstant.Icon;

		export import Size = Self.DelimiterConstant.Size;

		export import I18n = Self.DelimiterConstant.I18n;

	}

	namespace DelimiterConstant {
		enum Icon {
			CIRCLE,
			SQUARE,
			LINE,
		}

		enum Size {
			SMALL,
			MEDIUM,
			LARGE,
		}

		enum I18n {
			GO_TO,
		}

	}

	function DeprecationPanel(props: {classList: (string | PackageCore.Style | globalThis.Array<string> | globalThis.Array<PackageCore.Style>); children: PackageCore.VDom.Children}): PackageCore.JSX.Element;

	export class Divider extends PackageCore.Component {
		constructor(options?: Self.Divider.Options);

		orientation: Self.Divider.Orientation;

		inset: Self.Divider.Inset;

		gap: Self.Divider.Gap;

		setOrientation(orientation: Self.Divider.Orientation): void;

		setInset(inset: Self.Divider.Inset): void;

		setGap(gap: Self.Divider.Gap): void;

		static Horizontal(props: Self.Divider.Options): PackageCore.JSX.Element;

		static Vertical(props: Self.Divider.Options): PackageCore.JSX.Element;

		static getStyles(): void;

	}

	export namespace Divider {
		interface Options extends PackageCore.Component.Options {
			orientation?: Self.Divider.Orientation;

			inset?: Self.Divider.Inset;

			gap?: Self.Divider.Gap;

		}

		enum Orientation {
			HORIZONTAL,
			VERTICAL,
		}

		enum Inset {
			NONE,
			START,
			END,
			BOTH,
		}

		enum Gap {
			NONE,
			START,
			END,
			BOTH,
		}

	}

	export class Dropdown extends Self.DataSourceComponent implements PackageCore.InputComponent {
		constructor(options: Self.Dropdown.Options);

		selectedItem: any;

		selectedIndex: number;

		selectedText: string;

		selectedValue: any;

		dropDownOpened: boolean;

		inputText: string;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		empty: boolean;

		mandatory: boolean;

		allowEmpty: boolean;

		picker: (Self.ListBoxPicker.Options | null);

		size: Self.Dropdown.Size;

		onSelectionChanged: (Self.Dropdown.SelectionChangedCallback | null);

		select(args: object): void;

		unselect(options?: {reason?: string}): void;

		openDropDown(args: object): void;

		closeDropDown(args?: object): void;

		toggleDropDown(args: object): void;

		acceptChanges(): void;

		setAllowEmpty(value: boolean): void;

		selectAll(): void;

		static Event: Self.Dropdown.EventTypes;

	}

	export namespace Dropdown {
		interface Options extends Self.DataSourceComponent.Options {
			acceptChangesOnFocusOut?: boolean;

			allowCustomItem?: boolean;

			allowCustomText?: boolean;

			allowEmpty?: boolean;

			autoSuggestOptions?: object;

			comparator?: Self.Dropdown.ComparatorCallback;

			displayMember?: Self.DataSourceComponent.DisplayMember;

			filterable?: boolean;

			itemContent?: (item: Self.ListItem, renderData: object) => (PackageCore.Component | PackageCore.JSX.Element);

			noDataMessage?: string;

			openDropDownOnClick?: boolean;

			openDropDownOnFocus?: boolean;

			picker?: Self.ListBoxPicker.Options;

			placeholder?: (string | PackageCore.Translation | PackageCore.Component);

			selectionContent?: (args: {selectedItem: any}) => PackageCore.JSX.Element;

			showLoaderOnDataAccess?: boolean;

			valueMember?: Self.DataSourceComponent.ValueMember;

			mandatory?: boolean;

			selectedItem?: any;

			selectedIndex?: number;

			selectedValue?: any;

			selectedText?: string;

			size?: Self.Dropdown.Size;

			onSelectionChanged?: Self.Dropdown.SelectionChangedCallback;

		}

		type SelectionChangedCallback = (args: Self.Dropdown.SelectionChangedArgs, sender: Self.Dropdown) => void;

		type ComparatorCallback = (left: any, right: any) => boolean;

		interface SelectionChangedArgs {
			item: any;

			previousItem: any;

			value: any;

			previousValue: any;

			text: any;

			previousText: any;

			index: (number | null);

			previousIndex: (number | null);

			reason: Self.Dropdown.Reason;

		}

		interface EventTypes extends Self.DataSourceComponent.EventTypes {
			SELECTED_ITEM_CHANGED: string;

			PICKER_OPENING: string;

			PICKER_OPENED: string;

			PICKER_CLOSING: string;

			PICKER_CLOSED: string;

		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
			REDWOOD_FIELD,
		}

		enum Reason {
			CALL,
			UNSELECT,
			ACCEPT,
			SELECTION_CHANGED,
			AUTO_SUGGEST,
			CLICK,
			DATA_LOADED,
			DATA_SOURCE_UNBOUND,
			RELOAD,
			CLEAR,
			INPUT,
			KEY_ARROW_DOWN,
			KEY_ARROW_UP,
		}

		enum I18N {
			OPEN_SELECTION,
			NO_DATA_AVAILABLE,
		}

		export import Size = Self.InputSize;

	}

	export class DropdownCell extends Self.GridCell {
		constructor(options: object);

		dataSource: PackageCore.DataSource;

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		valueMember: (Self.DataSourceComponent.ValueMember | null);

		bindToValue: boolean;

		valueDisplayMember: Self.DataSourceComponent.DisplayMember;

		dropdown: (Self.Dropdown | null);

		widgetOptions: (Self.Dropdown.Options | Self.GridCell.WidgetOptionsCallback<Self.Dropdown.Options>);

		setDataSource(dataSource: (PackageCore.DataSource | null)): void;

	}

	export namespace DropdownCell {
	}

	export class DropdownColumn extends Self.GridColumn {
		constructor(options: Self.DropdownColumn.Options);

		dataSource: (PackageCore.DataSource | null);

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		valueMember: (Self.DataSourceComponent.ValueMember | null);

		bindToValue: boolean;

		valueDisplayMember: (Self.DataSourceComponent.DisplayMember | null);

		widgetOptions: (Self.Dropdown.Options | Self.GridColumn.WidgetOptionsCallback<Self.Dropdown.Options> | null);

	}

	export namespace DropdownColumn {
		interface Options extends Self.GridColumn.Options {
			dataSource?: PackageCore.DataSource;

			valueMember?: Self.DataSourceComponent.ValueMember;

			displayMember?: Self.DataSourceComponent.DisplayMember;

			bindToValue?: boolean;

			valueDisplayMember?: Self.DataSourceComponent.DisplayMember;

			widgetOptions?: (Self.Dropdown.Options | Self.GridColumn.WidgetOptionsCallback<Self.Dropdown.Options>);

			dataSourceConfigurator?: Self.DropdownColumn.DataSourceConfiguratorCallback;

		}

		type DataSourceConfiguratorCallback = (row: Self.GridDataRow) => (PackageCore.DataSource | null);

		export import Cell = Self.DropdownCell;

	}

	export class EllipsisTooltip {
		constructor(options?: Self.EllipsisTooltip.Options & {content?: (string | PackageCore.Component | PackageCore.JSX.Element)});

		shown: boolean;

		attach(args: object): void;

		detach(): void;

		show(): void;

		hide(): void;

		private getComponents(): void;

	}

	export namespace EllipsisTooltip {
		interface Options {
			content: any;

		}

	}

	export class Favorite extends PackageCore.Component {
		constructor(options?: Self.Favorite.Options);

		value: boolean;

		icon: Self.Favorite.Icon;

		size: Self.Favorite.Size;

		color: Self.Favorite.Color;

		onToggled: (Self.Favorite.ToggledCallback | null);

		setValue(value: boolean, args?: {reason?: (symbol | string)}): void;

		toggle(args?: {reason?: (symbol | string)}): void;

		static Event: Self.Favorite.EventTypes;

	}

	export namespace Favorite {
		interface Options extends PackageCore.Component.Options {
			value?: boolean;

			icon?: Self.Favorite.Icon;

			size?: Self.Favorite.Size;

			color?: Self.Favorite.Color;

			onToggled?: Self.Favorite.ToggledCallback;

		}

		type ToggledCallback = (args: Self.Favorite.ToggledArgs, sender: Self.Favorite) => void;

		interface ToggledArgs {
			value: boolean;

			previousValue: boolean;

			reason: Self.Favorite.Reason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TOGGLED: string;

		}

		enum Icon {
			STAR,
			HEART,
		}

		enum Size {
			SMALL,
			DEFAULT,
			LARGE,
		}

		enum Color {
			DEFAULT,
			NEUTRAL,
			SUCCESS,
			WARNING,
			DANGER,
			INFO,
			TEAL,
			ORANGE,
			TURQUOISE,
			TAUPE,
			GREEN,
			PINK,
			BROWN,
			LILAC,
			YELLOW,
			PURPLE,
			BLUE,
			PINE,
			ERROR,
			THEMED,
		}

		enum Reason {
			ENTER,
			SPACE,
			ESCAPE,
			CLICK,
			CALL,
		}

	}

	export class Field extends PackageCore.Component {
		constructor(options?: Self.Field.Options);

		inline: boolean;

		label: (string | number | PackageCore.Translation | null);

		control: (PackageCore.Component | PackageCore.JSX.Element | Self.Field.ControlOptions | null);

		children: PackageCore.VDom.Children;

		activeControl: (PackageCore.Component | PackageCore.JSX.Element);

		assistiveContent: (PackageCore.Component | PackageCore.JSX.Element);

		mode: Self.Field.Mode;

		mandatory: boolean;

		infoIcons: globalThis.Array<(Self.Image | PackageCore.JSX.Element)>;

		helperButtons: globalThis.Array<Self.Field.ButtonOption>;

		size: Self.Field.Size;

		offset: boolean;

		orientation: Self.Field.Orientation;

		labelJustification: Self.Field.LabelJustification;

		labelWrap: (boolean | number);

		fieldLevelHelp: (Self.Field.FieldLevelHelpCallback | Self.HelpService.FieldLevelHelpOptions);

		bloom: boolean;

		setInline(value: boolean): void;

		setLabel(value: (string | number | PackageCore.Translation)): void;

		setControl(value: (PackageCore.Component | PackageCore.JSX.Element | Self.Field.ControlOptions)): void;

		setAssistiveContent(value: (PackageCore.Component | PackageCore.JSX.Element)): void;

		setMode(value: Self.Field.Mode): void;

		setMandatory(value: boolean): void;

		setInfoIcons(value: globalThis.Array<(Self.Image | PackageCore.JSX.Element)>): void;

		setHelperButtons(buttons: globalThis.Array<Self.Field.ButtonOption>): void;

		clearStatus(): void;

		success(message: (string | PackageCore.Translation | PackageCore.Component)): void;

		info(message: (string | PackageCore.Translation | PackageCore.Component)): void;

		warning(message: (string | PackageCore.Translation | PackageCore.Component)): void;

		error(message: (string | PackageCore.Translation | PackageCore.Component)): void;

		pending(message: (string | PackageCore.Translation | PackageCore.Component)): void;

		setSize(size: Self.Field.Size): void;

		setOffset(offset: boolean): void;

		setOrientation(value: Self.Field.Orientation): void;

		setLabelJustification(value: Self.Field.LabelJustification): void;

		protected _selectControlByMode(mode: Self.Field.Mode): (PackageCore.Component | PackageCore.JSX.Element | Self.Field.ControlOptions | null);

		protected _onControlChange(): void;

		static Horizontal(props: Self.Field.Options): PackageCore.JSX.Element;

		static Vertical(props: Self.Field.Options): PackageCore.JSX.Element;

		static Inline(props: Self.Field.Options): PackageCore.JSX.Element;

		static Event: Self.Field.EventTypes;

	}

	export namespace Field {
		interface ControlOptions {
			editable: PackageCore.Component;

			readOnly: PackageCore.Component;

		}

		interface ButtonOption {
			icon: Self.Image.Source;

			label: (string | PackageCore.Translation);

			action: () => void;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			label?: (string | number | PackageCore.Translation);

			control?: (PackageCore.Component | PackageCore.JSX.Element | Self.Field.ControlOptions);

			assistiveContent?: (PackageCore.Component | PackageCore.JSX.Element);

			mode?: Self.Field.Mode;

			mandatory?: boolean;

			infoIcons?: globalThis.Array<(Self.Image | PackageCore.JSX.Element)>;

			helperButtons?: globalThis.Array<Self.Field.ButtonOption>;

			fieldLevelHelp?: (Self.Field.FieldLevelHelpCallback | Self.HelpService.FieldLevelHelpOptions);

			size?: Self.Field.Size;

			offset?: boolean;

			orientation?: Self.Field.Orientation;

			labelJustification?: Self.Field.LabelJustification;

			labelWrap?: (boolean | number);

			inline?: boolean;

			bloom?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			MODE_CHANGED: string;

		}

		type FieldLevelHelpCallback = (label: Self.Label) => void;

		enum Mode {
			EDIT,
			VIEW,
		}

		enum Orientation {
			HORIZONTAL,
			VERTICAL,
		}

		enum LabelJustification {
			START,
			END,
		}

		enum Size {
			AUTO,
			SMALL,
			MEDIUM,
			LARGE,
			XLARGE,
			XXLARGE,
			STRETCH,
		}

		export import Status = PackageCore.Component.Status;

		enum VisualStyle {
			DEFAULT,
			REDWOOD_STANDALONE,
		}

	}

	export class FieldGroup extends PackageCore.Component {
		constructor(options?: Self.FieldGroup.Options);

		content: (PackageCore.JSX.Element | PackageCore.Component);

		children: PackageCore.VDom.Children;

		title: (string | number | PackageCore.Translation | null);

		titleControls: ((PackageCore.Component | PackageCore.VDom.Element) | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)> | null);

		color: Self.FieldGroup.Color;

		collapsed: boolean;

		collapsible: boolean;

		onExpanded: Self.FieldGroup.ExpandedCallback;

	}

	export namespace FieldGroup {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			title: (string | number | PackageCore.Translation);

			titleControls?: ((PackageCore.Component | PackageCore.VDom.Element) | globalThis.Array<(PackageCore.Component | PackageCore.VDom.Element)>);

			color?: Self.FieldGroup.Color;

			collapsible?: boolean;

			collapsed?: boolean;

			onExpanded?: Self.FieldGroup.ExpandedCallback;

		}

		type ExpandedCallback = (args: Self.FieldGroup.ExpandedCallbackArgs) => void;

		interface ExpandedCallbackArgs {
			expanded: boolean;

		}

		enum Color {
			THEMED,
			NEUTRAL,
		}

	}

	namespace FieldOptions {
	}

	export class FilePicker extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.FilePicker.Options);

		fileTypes: globalThis.Array<string>;

		multiSelect: boolean;

		tooltipEnabled: boolean;

		emptyText: string;

		labelText: (Self.FilePicker.LabelTextCallback | null);

		valueValidator: (Self.FilePicker.ValueValidatorCallback | null);

		acceptInvalidValue: boolean;

		buttonPosition: Self.FilePicker.ButtonPosition;

		buttonOptions: Self.Button.Options;

		clearButton: boolean;

		selectedFiles: globalThis.Array<File>;

		empty: boolean;

		mandatory: boolean;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		messageTimeout: number;

		onFilesChanged: (Self.FilePicker.FilesChangedCallback | null);

		setSelectedFiles(files: globalThis.Array<File>, options?: {validate?: boolean; showValidationMessage?: boolean; reason?: string}): globalThis.Promise<void>;

		setFileTypes(value: globalThis.Array<string>): void;

		setMultiSelect(value: boolean): void;

		setTooltipEnabled(value: boolean): void;

		setButtonOptions(options: Self.Button.Options): void;

		setButtonPosition(value: Self.FilePicker.ButtonPosition): void;

		setEmptyText(value: (string | PackageCore.Translation)): void;

		setLabel(value: (files: globalThis.Array<File>) => string): void;

		setValueValidator(value: (Self.FilePicker.ValueValidatorCallback | null)): void;

		setAcceptInvalidValue(value: boolean): void;

		setMandatory(value: boolean): void;

		open(): void;

		clear(options?: {reason?: string}): void;

		private validate(files: globalThis.Array<File>, options?: {showMessage?: boolean}): (globalThis.Promise<boolean> | boolean);

		private renderInput(): void;

		private renderButton(): void;

		private renderClearButton(): void;

		static Event: Self.FilePicker.EventTypes;

	}

	export namespace FilePicker {
		interface Options extends PackageCore.Component.Options {
			selectedFiles?: globalThis.Array<File>;

			acceptInvalidValue?: boolean;

			buttonOptions?: Self.Button.Options;

			buttonPosition?: Self.FilePicker.ButtonPosition;

			clearButton?: boolean;

			emptyText?: (string | PackageCore.Translation);

			fileTypes?: globalThis.Array<string>;

			labelText?: Self.FilePicker.LabelTextCallback;

			messageTimeout?: number;

			multiSelect?: boolean;

			tooltipEnabled?: boolean;

			valueValidator?: Self.FilePicker.ValueValidatorCallback;

			mandatory?: boolean;

			onFilesChanged?: Self.FilePicker.FilesChangedCallback;

		}

		type FilesChangedCallback = (args: Self.FilePicker.FilesChangedArgs, sender: Self.FilePicker) => void;

		interface FilesChangedArgs {
			files: globalThis.Array<File>;

			previousFiles: globalThis.Array<File>;

			reason: Self.FilePicker.ChangeReason;

		}

		type ValueValidatorCallback = (previousFiles: globalThis.Array<File>, newFiles: globalThis.Array<File>) => (globalThis.Promise<(boolean | Self.FilePicker.ValidationResult)> | Self.FilePicker.ValidationResult | boolean);

		interface ValidationResult {
			valid: boolean;

			message: string;

		}

		type LabelTextCallback = (files: globalThis.Array<File>) => (string | PackageCore.Translation);

		interface EventTypes extends PackageCore.Component.EventTypes {
			FILES_CHANGED: string;

		}

		enum FileType {
			AUDIO,
			VIDEO,
			IMAGE,
			MEDIA,
		}

		enum ButtonPosition {
			START,
			END,
		}

		enum OpenReason {
			OPEN_CALL,
			BUTTON_CLICK,
		}

		enum ChangeReason {
			SELECT,
			DROP,
			CLEAR_BUTTON,
			CLEAR_CALL,
		}

		enum I18N {
			BUTTON_LABEL_STANDARD,
			BUTTON_LABEL_UPLOADING,
			LABEL_EMPTY,
			LABEL_FILE_NOT_ACCEPTED,
			LABEL_FILE_ATTACHED,
			LABEL_0_FILES_SELECTED,
			LABEL_FILETYPE_NOT_SUPPORTED,
		}

	}

	export class FilterChip extends PackageCore.Component {
		constructor(options: Self.FilterChip.Options);

		selectedValue: any;

		acceptedValue: any;

		label: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		valueFormatter: (Self.FilterChip.ValueFormatterCallback | string);

		valueComparator: Self.FilterChip.ValueComparatorCallback;

		picker: (Self.Picker | null);

		size: Self.FilterChip.Size;

		pickerOpened: boolean;

		emptyValue: any;

		activated: boolean;

		onValueChanged: (Self.FilterChip.ValueChangedCallback | null);

		onValueAccepted: (Self.FilterChip.ValueAcceptedCallback | null);

		setSelectedValue(value: any, options?: {reason?: symbol; accept?: boolean}): void;

		clear(options?: {reason?: symbol}): boolean;

		setSize(value: Self.FilterChip.Size): void;

		openPicker(args?: object): void;

		closePicker(args?: object): void;

		togglePicker(args?: object): void;

		private renderValuePanel(): PackageCore.JSX.Element;

		private renderSeparator(): PackageCore.JSX.Element;

		private renderValue(selectedValue: any): (PackageCore.Component | PackageCore.JSX.Element);

		private renderValueFromString(text: string): PackageCore.JSX.Element;

		private renderClearButton(): PackageCore.JSX.Element;

		private renderLabel(): PackageCore.JSX.Element;

		private createPicker(definition: Self.FilterChip.PickerCallback): Self.Picker;

		private assignDescribedByProperty(): void;

		private handlePickerOpened(args: object): void;

		private handlePickerClosed(args?: object): void;

		private handlePickerUpdated(): void;

		private isActivated(): boolean;

		static defaultValueComparator(selectedValue: any, emptyValue: any, filterChip: Self.FilterChip): boolean;

		static defaultPicker(options: Self.FilterChipPicker.Options): Self.FilterChip.PickerCallback;

		static singlePicker(options: Self.RadioGroupPicker.Options): Self.FilterChip.PickerCallback;

		static defaultValueFormatter(options?: Self.FilterChip.DefaultValueFormatterOptions): Self.FilterChip.ValueFormatterCallback;

		static Custom(props: Self.FilterChip.Options): PackageCore.JSX.Element;

		static default(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions: Self.FilterChipPicker.Options, valueFormatterOptions?: Self.FilterChip.DefaultValueFormatterOptions): Self.FilterChip;

		static Default(props: Self.FilterChip.FactoryOptions & {pickerOptions?: Self.FilterChipPicker.Options; valueFormatterOptions?: Self.FilterChip.DefaultValueFormatterOptions}): PackageCore.JSX.Element;

		static single(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions: Self.RadioGroupPicker.Options, valueFormatterOptions?: Self.FilterChip.DefaultValueFormatterOptions): Self.FilterChip;

		static Single(props: Self.FilterChip.FactoryOptions & {pickerOptions?: Self.RadioGroupPicker.Options; valueFormatterOptions?: Self.FilterChip.DefaultValueFormatterOptions}): PackageCore.JSX.Element;

		static Multi(props: Self.FilterChip.FactoryOptions & {pickerOptions?: Self.FilterChipPicker.Options; valueFormatterOptions?: Self.FilterChip.DefaultValueFormatterOptions}): PackageCore.JSX.Element;

		static datePicker(options?: Self.CalendarPicker.Options): Self.FilterChip.PickerCallback;

		static dateValueFormatter(formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip.ValueFormatterCallback;

		static date(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions?: Self.CalendarPicker.Options, formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip;

		static Date(props: Self.FilterChip.FactoryOptions & {pickerOptions?: Self.CalendarPicker.Options; formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)}): PackageCore.JSX.Element;

		static dateRangePicker(options?: Self.DateRangePicker.Options): Self.FilterChip.PickerCallback;

		static dateRangeValueFormatter(formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip.ValueFormatterCallback;

		static dateRange(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions?: Self.DateRangePicker.Options, formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip;

		static DateRange(props: Self.FilterChip.FactoryOptions & {pickerOptions?: Self.DateRangePicker.Options; formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)}): PackageCore.JSX.Element;

		static timePicker(options?: Self.TimeSelectorPicker.Options): Self.FilterChip.PickerCallback;

		static timeValueFormatter(formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip.ValueFormatterCallback;

		static time(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions?: Self.TimeSelectorPicker.Options, formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip;

		static Time(props: Self.FilterChip.FactoryOptions & {pickerOptions?: Self.TimeSelectorPicker.Options; formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)}): PackageCore.JSX.Element;

		static timeRangePicker(options?: object): Self.FilterChip.PickerCallback;

		static timeRangeValueFormatter(formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip.ValueFormatterCallback;

		static timeRange(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions?: object, formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)): Self.FilterChip;

		static TimeRange(props: Self.FilterChip.FactoryOptions & {pickerOptions?: object; formatOrFormatter?: (string | Self.FilterChip.FormatterCallback)}): PackageCore.JSX.Element;

		static textBoxPicker(options?: object): Self.FilterChip.PickerCallback;

		static textBoxValueFormatter(): Self.FilterChip.ValueFormatterCallback;

		static textBox(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions?: object): Self.FilterChip;

		static TextBox(props: Self.FilterChip.FactoryOptions & {pickerOptions?: object}): PackageCore.JSX.Element;

		static checkBoxPicker(options?: object): Self.FilterChip.PickerCallback;

		static checkBoxValueFormatter(): Self.FilterChip.ValueFormatterCallback;

		static checkBox(filterChipOptions: Self.FilterChip.FactoryOptions, pickerOptions?: object): Self.FilterChip;

		static CheckBox(props: Self.FilterChip.FactoryOptions & {pickerOptions?: object}): PackageCore.JSX.Element;

		static toggle(filterChipOptions: Self.FilterChip.FactoryOptions): Self.FilterChip;

		static Toggle(props: Self.FilterChip.FactoryOptions): PackageCore.JSX.Element;

		static Event: Self.FilterChip.EventTypes;

		static DEFAULT_PICKER_OPTIONS: object;

	}

	export namespace FilterChip {
		type ValueComparatorCallback = (selectedValue: any, emptyValue: any, filterChip: Self.FilterChip) => boolean;

		type PickerCallback = (filterChip: Self.FilterChip) => Self.Picker;

		type ValueFormatterCallback = (selectedValue: any, filterChip: Self.FilterChip) => globalThis.Promise<(string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element)>;

		type FormatterCallback = (value: any, filterChip: Self.FilterChip, formatService: PackageCore.FormatService) => (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		interface Options extends PackageCore.Component.Options {
			emptyValue?: any;

			valueComparator?: Self.FilterChip.ValueComparatorCallback;

			label: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			picker: Self.FilterChip.PickerCallback;

			selectedValue?: any;

			size?: Self.FilterChip.Size;

			valueFormatter?: (Self.FilterChip.ValueFormatterCallback | string);

			multiselectable?: boolean;

			role?: PackageCore.AriaRole;

			onValueChanged?: Self.FilterChip.ValueChangedCallback;

			onValueAccepted?: Self.FilterChip.ValueAcceptedCallback;

		}

		interface FactoryOptions extends PackageCore.Component.Options {
			emptyValue?: any;

			valueComparator?: Self.FilterChip.ValueComparatorCallback;

			label: (string | PackageCore.Component | PackageCore.Translation);

			selectedValue?: any;

			size?: Self.FilterChip.Size;

		}

		type ValueChangedCallback = (args: Self.FilterChip.ValueChangedArgs, sender: Self.FilterChip) => void;

		interface ValueChangedArgs {
			value: any;

			previousValue: any;

			reason: Self.FilterChip.Reason;

		}

		type ValueAcceptedCallback = (args: Self.FilterChip.ValueAcceptedArgs, sender: Self.FilterChip) => void;

		interface ValueAcceptedArgs {
			value: any;

			previousValue: any;

			reason: Self.FilterChip.Reason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_VALUE_CHANGED: string;

			SELECTED_VALUE_ACCEPTED: string;

			ACTIVATED_STATE_CHANGED: string;

			PICKER_OPENING: string;

			PICKER_OPENED: string;

			PICKER_CLOSING: string;

			PICKER_CLOSED: string;

		}

		interface DefaultValueFormatterOptions {
			displayMember?: Self.DataSourceComponent.DisplayMember;

			valueMember?: Self.DataSourceComponent.ValueMember;

		}

		enum Reason {
			CALL,
			CLEAR,
			CLEAR_BUTTON,
			CLEAR_KEY,
			PICKER,
			PICKER_UPDATE,
			CLICK,
			KEY_ARROW_DOWN,
			KEY_ARROW_UP,
			KEY_ESCAPE,
			KEY_ENTER,
		}

		enum Size {
			SMALL,
			MEDIUM,
		}

		enum I18n {
			ALL,
			CLEAR_FILTER,
			CHECKBOX_YES,
			CHECKBOX_NO,
		}

	}

	export class FilterChipPicker extends Self.Picker {
		constructor(options: Self.FilterChipPicker.Options);

		dataSource: (PackageCore.DataSource | null);

		listBox: Self.ListBox;

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		valueMember: (Self.DataSourceComponent.ValueMember | null);

		searchMember: (Self.DataSourceComponent.ValueMember | null);

		private handleSelectionChanged(args: Self.ListBox.SelectionChangedArgs): void;

		private handleListItemClicked(args: {buttons: object}): void;

		private handleListCursorMoved(args: {currentItem: PackageCore.Component}): void;

		private forwardMessageToList(message: PackageCore.RoutedMessage, result: object): void;

	}

	export namespace FilterChipPicker {
		interface Options extends Self.Picker.Options {
			dataSource?: PackageCore.DataSource;

			listBox?: Self.ListBox.Options;

			displayMember?: Self.DataSourceComponent.DisplayMember;

			valueMember?: Self.DataSourceComponent.ValueMember;

			searchMember?: Self.DataSourceComponent.ValueMember;

			comparator?: (left: any, right: any) => boolean;

			search?: (boolean | Self.FilterChipPicker.SearchSettings | Self.FilterChipPicker.SearchPredicate);

		}

		type SearchPredicate = (item: any, string: string) => boolean;

		interface SearchSettings {
			predicate?: Self.FilterChipPicker.SearchPredicate;

			textBox?: Self.TextBox.Options;

		}

	}

	/**
	 * @deprecated Replaced by ListView.Filter JSX
	 */
	export namespace FilterFactory {
		type FilterPredicateCallback = (item: any, value: any) => boolean;

		interface Filter {
			id: any;

			filterPredicate: Self.FilterFactory.FilterPredicateCallback;

			filterChip: Self.FilterChip;

		}

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createCheckBoxFilter(options: {automationId?: string; id: string; label: (string | PackageCore.Translation); binding?: string; filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: boolean}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createToggleFilter(options: {automationId?: string; id: string; label: (string | PackageCore.Translation); binding?: string; filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: boolean}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createTextBoxFilter(options: {automationId?: string; id: string; label: (string | PackageCore.Translation); binding?: string; filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: string; matchingOperator?: Self.FilterFactory.TextBoxMatchingOperator}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createDropdownFilter(options: {automationId?: string; id: string; label: (string | PackageCore.Translation); dataProvider: () => PackageCore.DataSource; valueMember: string; displayMember: string; binding?: string; filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: any}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createMultiselectDropdownFilter(options: {automationId?: string; id: string; label: (string | PackageCore.Translation); dataProvider: () => PackageCore.DataSource; valueMember: string; displayMember: string; binding?: string; filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: globalThis.Array<any>}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createDateFilter(options: {automationId?: string; id: string; label: (string | PackageCore.Translation); binding?: (string | ((item: any) => PackageCore.Date)); filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: PackageCore.Date}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createDateRangeFilter(options: {automationId?: string; id: string; label: (string | PackageCore.Translation); binding?: (string | ((item: any) => PackageCore.Date)); filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: Self.DateRange.Range}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createTimeFilter(options: {id: string; label: (string | PackageCore.Translation); binding?: (string | ((item: any) => PackageCore.Time)); format?: string; filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: PackageCore.Time}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function createTimeRangeFilter(options: {id: string; label: (string | PackageCore.Translation); binding?: (string | ((item: any) => PackageCore.Time)); format?: string; filterPredicate?: Self.FilterFactory.FilterPredicateCallback; value?: {start: PackageCore.Time; end: PackageCore.Time}}): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		function create(type: Self.FilterFactory.Type, options: object): Self.FilterFactory.Filter;

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		enum Type {
			TEXT_BOX,
			DROPDOWN,
			MULTISELECT_DROPDOWN,
			CHECK_BOX,
			DATE,
			TIME,
			DATE_RANGE,
			TIME_RANGE,
		}

		/**
		 * @deprecated Replaced by ListView.Filter JSX
		 */
		export import TextBoxMatchingOperator = Self.ListViewConstant.TextBoxFilterMatchingOperator;

	}

	export class FilterPanel extends PackageCore.Component {
		constructor(options: Self.FilterPanel.Options);

		state: globalThis.Array<Self.FilterPanel.FilterState>;

		/**
		 * @deprecated
		 */
		filters: globalThis.Array<Self.FilterPanel.FilterDefinition>;

		activeFilters: globalThis.Array<Self.FilterPanel.FilterState>;

		activeFiltersCount: number;

		hasActiveFilters: boolean;

		children: PackageCore.VDom.Children;

		values: (Self.FilterPanel.FilterValueMap | null);

		showClearAll: boolean;

		orientation: Self.FilterPanel.Orientation;

		filtersExpanded: boolean;

		onFiltersChanged: (Self.FilterPanel.FiltersChangedCallback | null);

		onFiltersExpanded: (Self.FilterPanel.FiltersExpandedCallback | null);

		/**
		 * @deprecated
		 */
		filtersVisibilityToggle: Self.FilterPanelToggle;

		getState(): globalThis.Array<Self.FilterPanel.FilterState>;

		getActiveFiltersCount(): number;

		isAnyFilterActive(): boolean;

		clearAllFilters(): void;

		static Horizontal(props?: Self.FilterPanel.Options): PackageCore.JSX.Element;

		static Vertical(props?: Self.FilterPanel.Options): PackageCore.JSX.Element;

		static Item(props: Self.FilterPanel.ItemOptions): PackageCore.JSX.Element;

		static Event: Self.FilterPanel.EventTypes;

	}

	export namespace FilterPanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			filters?: globalThis.Array<Self.FilterPanel.FilterDefinition>;

			values?: Self.FilterPanel.FilterValueMap;

			orientation?: Self.FilterPanel.Orientation;

			showClearAll?: boolean;

			horizontalExpansionEnabled?: boolean;

			filtersExpanded?: boolean;

			onFiltersChanged?: Self.FilterPanel.FiltersChangedCallback;

			onFiltersExpanded?: Self.FilterPanel.FiltersExpandedCallback;

		}

		type FilterId = (string | number);

		type FilterValueMap = Record<Self.FilterPanel.FilterId, any>;

		interface FilterDefinition {
			id: Self.FilterPanel.FilterId;

			filterChip: Self.FilterChip;

		}

		interface FilterState {
			id: Self.FilterPanel.FilterId;

			activated: boolean;

			value: any;

		}

		type FiltersChangedCallback = (args: Self.FilterPanel.FiltersChangedCallbackArgs) => void;

		interface FiltersChangedCallbackArgs {
			values: Self.FilterPanel.FilterValueMap;

			previousValues: Self.FilterPanel.FilterValueMap;

			changedFilters: Self.FilterPanel.FilterValueMap;

		}

		type FiltersExpandedCallback = (args: Self.FilterPanel.FiltersExpandedCallbackArgs) => void;

		interface FiltersExpandedCallbackArgs {
			expanded: boolean;

		}

		interface ItemOptions {
			children?: PackageCore.VDom.Children;

			id: Self.FilterPanel.FilterId;

			key?: any;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			STATE_UPDATED: string;

		}

		export import Toggle = Self.FilterPanelToggle;

		enum Reason {
			FILTER_VALUE_CHANGED,
			CLEAR_ALL,
			FILTERS_SETTER,
			VISIBILITY_CHANGED,
		}

		enum Orientation {
			VERTICAL,
			HORIZONTAL,
		}

	}

	class FilterPanelToggle extends PackageCore.Component {
		constructor(options?: Self.FilterPanelToggle.Options);

		toggled: boolean;

		activeFiltersCount: number;

		behavior: Self.Button.Behavior;

		action: Self.Button.ActionCallback;

		onToggled: (Self.FilterPanelToggle.ToggledCallback | null);

	}

	namespace FilterPanelToggle {
		interface Options {
			toggled?: boolean;

			activeFiltersCount?: number;

			FilterPanelToggle?: Self.Button.Behavior;

			action?: Self.Button.ActionCallback;

			onToggled?: Self.FilterPanelToggle.ToggledCallback;

		}

		type ToggledCallback = (args: Self.FilterPanelToggle.ToggledCallbackArgs, sender: Self.FilterPanelToggle) => void;

		interface ToggledCallbackArgs {
			toggled: boolean;

		}

		export import Behavior = Self.Button.Behavior;

	}

	class FilterPositionToggleGroup extends PackageCore.Component {
		constructor(options?: Self.FilterPositionToggleGroup.Options);

		filtersPosition: Self.FilterPositionToggleGroup.FiltersPosition;

		activeFiltersCount: number;

		onFiltersPositionChanged: Self.FilterPositionToggleGroup.FiltersPositionChangedCallback;

	}

	namespace FilterPositionToggleGroup {
		interface Options {
			filtersPosition?: Self.FilterPositionToggleGroup.FiltersPosition;

			activeFiltersCount?: number;

			onFiltersPositionChanged?: Self.FilterPositionToggleGroup.FiltersPositionChangedCallback;

		}

		type FiltersPositionChangedCallback = (args: Self.FilterPositionToggleGroup.FiltersPositionChangedCallbackArgs, sender: Self.FilterPositionToggleGroup) => void;

		interface FiltersPositionChangedCallbackArgs {
			position: Self.FilterPositionToggleGroup.FiltersPosition;

			previousPosition: Self.FilterPositionToggleGroup.FiltersPosition;

		}

		export import FiltersPosition = Self.ListViewConstant.FiltersPosition;

	}

	export function FixedLayout(props?: {topContent?: (PackageCore.Component | PackageCore.JSX.Element | null); children?: PackageCore.VDom.Children}): PackageCore.JSX.Element;

	export class FormContext {
	}

	export namespace FormContext {
	}

	export class FormattedText extends PackageCore.Component {
		constructor(options?: (Self.FormattedText.Options | string | number | PackageCore.Translation));

		text: (string | number | PackageCore.Translation);

		children: PackageCore.VDom.Children;

		formatter: Self.FormattedText.Formatter;

		options: Self.FormattedText.FormatterOptions;

		decorator: (PackageCore.Decorator | null);

		wrap: (boolean | number);

		whitespace: boolean;

		setText(text: (string | number | PackageCore.Translation)): void;

		setFormatter(formatter: Self.FormattedText.Formatter): void;

		setOptions(options: Self.FormattedText.FormatterOptions): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		setWrap(value: (boolean | number)): void;

		setWhitespace(value: boolean): void;

		setFormatterAndOptions(formatter: Self.FormattedText.Formatter, options: Self.FormattedText.FormatterOptions): void;

		private _attachEllipsisHelper(i18n: PackageCore.I18n): void;

		private _getFormattedItems(i18n: PackageCore.I18n): any;

		static markdown(text?: (string | number | PackageCore.Translation), options?: Self.FormattedText.Options): Self.FormattedText;

		static Markdown(): PackageCore.JSX.Element;

		static bold(text?: (string | number | PackageCore.Translation), formatterOptions?: Self.FormattedText.FormatterOptions, options?: Self.FormattedText.Options): Self.FormattedText;

		static Bold(): PackageCore.JSX.Element;

		static italic(text?: (string | number | PackageCore.Translation), formatterOptions?: Self.FormattedText.FormatterOptions, options?: Self.FormattedText.Options): Self.FormattedText;

		static Italic(): PackageCore.JSX.Element;

		static link(text?: (string | number | PackageCore.Translation), formatterOptions?: Self.FormattedText.FormatterOptions, options?: Self.FormattedText.Options): Self.FormattedText;

		static Link(): PackageCore.JSX.Element;

		static getStyles(): void;

	}

	export namespace FormattedText {
		interface FormatterOptions {
			highlights?: (globalThis.Array<string> | globalThis.Array<number> | globalThis.Array<PackageCore.Translation> | globalThis.Array<Self.FormattedText.LinkHighlight>);

			ignoreCase?: boolean;

			multiMatch?: boolean;

			linkOptions?: Self.Link.Options;

			textOptions?: Self.Text.Options;

		}

		interface LinkHighlight {
			content?: (string | number | PackageCore.Translation);

			url?: string;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			decorator?: PackageCore.Decorator;

			formatter?: Self.FormattedText.Formatter;

			options?: Self.FormattedText.FormatterOptions;

			text?: (string | number | PackageCore.Translation);

			whitespace?: boolean;

			wrap?: (boolean | number);

		}

		enum Formatter {
			NONE,
			BOLD,
			ITALIC,
			LINK,
			MARKDOWN,
			ACCESS_KEY,
		}

	}

	export class GanttChart extends PackageCore.Component {
		constructor(options: Self.GanttChart.Options);

		columns: globalThis.Array<Self.GanttChart.ColumnDefinition>;

		resources: globalThis.Array<Self.GanttChart.ResourceDefinition>;

		tasks: globalThis.Array<Self.GanttChart.TaskDefinition>;

		assignments: globalThis.Array<Self.GanttChart.AssignmentDefinition>;

		dependencies: globalThis.Array<Self.GanttChart.DependencyDefinition>;

		calendars: (globalThis.Array<Self.GanttChart.CalendarDefinition> | null);

		startDate: PackageCore.Date;

		endDate: PackageCore.Date;

		projectCalendar: Self.GanttChart.Id;

		resourceStyle: (string | PackageCore.Style | object | Self.GanttChart.ResourceStyleCallback | null);

		timeRanges: (globalThis.Array<Self.GanttChart.TimeRange> | null);

		resourceTimeRanges: (globalThis.Array<Self.GanttChart.ResourceTimeRange> | null);

		resourceTimeRangeContent: (Self.GanttChart.ResourceTimeRangeContentCallback | null);

		taskResize: boolean;

		taskDrag: boolean;

		rowHeight: (number | null);

		resizableStartColumnRegion: boolean;

		resizableEndColumnRegion: boolean;

		startColumnRegionMaxWidth: (number | null);

		endColumnRegionMaxWidth: (number | null);

		expanded: boolean;

		firstDayOfWeek: (number | null);

		showCriticalPath: boolean;

		showBaselines: boolean;

		viewPreset: (Self.GanttChart.ViewPreset | Self.GanttChart.ViewPresetConfig);

		taskColor: (Self.GanttChart.TaskColor | Self.GanttChart.TaskCustomColor | PackageCore.Color | Self.GanttChart.TaskColorCallback);

		taskHorizontalMargin: number;

		taskVerticalMargin: number;

		taskMinimumWidth: number;

		gridLines: Self.GanttChart.GridLines;

		resourceGridLines: boolean;

		gridColumnContent: (Self.GanttChart.GridColumnContentCallback | null);

		gridRowContent: (Self.GanttChart.GridRowContentCallback | null);

		taskTooltip: (Self.GanttChart.TaskTooltipCallback | null);

		taskLabel: (Self.GanttChart.TaskLabelCallback | null);

		taskStyle: (string | PackageCore.Style | object | Self.GanttChart.TaskStyleCallback | null);

		taskPosition: (Self.GanttChart.TaskPositionCallback | null);

		taskOuterLabel: (Self.GanttChart.TaskOuterLabelCallback | null);

		dragTaskPosition: (Self.GanttChart.DragTaskPositionCallback | null);

		baselineHeight: number;

		baselineColor: (PackageCore.Color | Self.GanttChart.BaselineColorCallback | null);

		baselineStyle: (string | PackageCore.Style | object | Self.GanttChart.BaselineStyleCallback | null);

		baselineTooltip: (Self.GanttChart.BaselineTooltipCallback | null);

		expandedResources: (globalThis.Array<Self.GanttChart.Id> | globalThis.Set<Self.GanttChart.Id> | null);

		timelineTooltip: (Self.GanttChart.TimelineTooltipCallback | null);

		taskResizeTooltip: (Self.GanttChart.TaskResizeTooltipCallback | null);

		taskResizeValidator: (Self.GanttChart.TaskResizeValidatorCallback | null);

		taskDragTooltip: (Self.GanttChart.TaskDragTooltipCallback | null);

		dropValidator: Self.GanttChart.DropValidatorCallback;

		dropPlaceholder: (Self.GanttChart.DropPlaceholder | null);

		onResourceClick: (Self.GanttChart.ResourceClickCallback | null);

		onResourceDoubleClick: (Self.GanttChart.ResourceClickCallback | null);

		onTaskClick: (Self.GanttChart.TaskClickCallback | null);

		onTaskDoubleClick: (Self.GanttChart.TaskClickCallback | null);

		onTaskContextMenu: (Self.GanttChart.TaskContextMenuCallback | null);

		onTaskResized: (Self.GanttChart.TaskResizedCallback | null);

		onTaskMoved: (Self.GanttChart.TaskMovedCallback | null);

		onTaskDropPlaceholderUpdate: (Self.GanttChart.TaskDropPlaceholderUpdateCallback | null);

		onResourceExpanded: (Self.GanttChart.ResourceExpandedCallback | null);

		scrollTo(args: {resourceId?: Self.GanttChart.Id; date?: PackageCore.Date; mode?: Self.GanttChart.ScrollToMode}): void;

		static weekendIntervals(startDate: PackageCore.Date, endDate: PackageCore.Date, options: Partial<Self.GanttChart.CalendarIntervalDefinition>): globalThis.Array<Self.GanttChart.CalendarIntervalDefinition>;

		static extendViewPreset(base: Self.GanttChart.ViewPreset, options: Partial<Self.GanttChart.ViewPresetConfig>): void;

	}

	export namespace GanttChart {
		interface Options extends PackageCore.Component.Options {
			columns: globalThis.Array<Self.GanttChart.ColumnDefinition>;

			resources: globalThis.Array<Self.GanttChart.ResourceDefinition>;

			tasks: globalThis.Array<Self.GanttChart.TaskDefinition>;

			assignments: globalThis.Array<Self.GanttChart.AssignmentDefinition>;

			dependencies?: globalThis.Array<Self.GanttChart.DependencyDefinition>;

			calendars?: globalThis.Array<Self.GanttChart.CalendarDefinition>;

			startDate: PackageCore.Date;

			endDate: PackageCore.Date;

			projectCalendar?: Self.GanttChart.Id;

			timeRanges?: globalThis.Array<Self.GanttChart.TimeRange>;

			resourceTimeRanges?: globalThis.Array<Self.GanttChart.ResourceTimeRange>;

			resourceTimeRangeContent?: Self.GanttChart.ResourceTimeRangeContentCallback;

			resourceStyle?: (string | PackageCore.Style | object | Self.GanttChart.ResourceStyleCallback);

			taskResize?: boolean;

			taskDrag?: boolean;

			taskHorizontalMargin?: number;

			taskVerticalMargin?: number;

			taskMinimumWidth?: number;

			rowHeight?: number;

			resizableStartColumnRegion?: boolean;

			resizableEndColumnRegion?: boolean;

			startColumnRegionMaxWidth?: (number | null);

			endColumnRegionMaxWidth?: (number | null);

			firstDayOfWeek?: number;

			showCriticalPath?: boolean;

			showBaselines?: boolean;

			baselineHeight?: number;

			baselineColor?: (PackageCore.Color | Self.GanttChart.BaselineColorCallback);

			baselineStyle?: (string | PackageCore.Style | object | Self.GanttChart.BaselineStyleCallback);

			baselineTooltip?: Self.GanttChart.BaselineTooltipCallback;

			viewPreset?: (Self.GanttChart.ViewPreset | Self.GanttChart.ViewPresetConfig);

			taskColor?: (Self.GanttChart.TaskColor | Self.GanttChart.TaskCustomColor | PackageCore.Color | Self.GanttChart.TaskColorCallback);

			gridLines?: Self.GanttChart.GridLines;

			resourceGridLines?: boolean;

			gridColumnContent?: Self.GanttChart.GridColumnContentCallback;

			gridRowContent?: Self.GanttChart.GridRowContentCallback;

			expandedResources?: (globalThis.Array<Self.GanttChart.Id> | globalThis.Set<Self.GanttChart.Id>);

			expanded?: boolean;

			dropValidator?: Self.GanttChart.DropValidatorCallback;

			taskTooltip?: Self.GanttChart.TaskTooltipCallback;

			taskResizeTooltip?: Self.GanttChart.TaskResizeTooltipCallback;

			taskDragTooltip?: Self.GanttChart.TaskDragTooltipCallback;

			taskResizeValidator?: Self.GanttChart.TaskResizeValidatorCallback;

			taskLabel?: Self.GanttChart.TaskLabelCallback;

			taskStyle?: (string | PackageCore.Style | object | Self.GanttChart.TaskStyleCallback);

			taskPosition?: Self.GanttChart.TaskPositionCallback;

			taskOuterLabel?: Self.GanttChart.TaskOuterLabelCallback;

			dragTaskPosition?: Self.GanttChart.DragTaskPositionCallback;

			onResourceClick?: Self.GanttChart.ResourceClickCallback;

			onResourceDoubleClick?: Self.GanttChart.ResourceClickCallback;

			onTaskClick?: Self.GanttChart.TaskClickCallback;

			onTaskDoubleClick?: Self.GanttChart.TaskClickCallback;

			onTaskContextMenu?: Self.GanttChart.TaskContextMenuCallback;

			onResourceExpanded?: Self.GanttChart.ResourceExpandedCallback;

			onTaskResized?: Self.GanttChart.TaskResizedCallback;

			onTaskMoved?: Self.GanttChart.TaskMovedCallback;

			onTaskDropPlaceholderUpdate?: Self.GanttChart.TaskDropPlaceholderUpdateCallback;

			timelineTooltip?: Self.GanttChart.TimelineTooltipCallback;

		}

		type Id = (string | number);

		interface ColumnDefinition {
			id: Self.GanttChart.Id;

			type?: Self.GanttChart.ColumnType;

			label: (string | Self.GanttChart.ColumnLabelCallback);

			labelAlignment?: Self.GanttChart.LabelAlignment;

			resourceLabel?: Self.GanttChart.ResourceLabelCallback;

			field?: string;

			controls?: globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>;

			region?: Self.GanttChart.ColumnRegion;

			resourceTooltip?: Self.GanttChart.ResourceTooltipCallback;

			width?: number;

		}

		interface ResourceDefinition {
			id: Self.GanttChart.Id;

			height?: number;

			taskColor?: (Self.GanttChart.TaskColor | Self.GanttChart.TaskCustomColor | PackageCore.Color);

			style?: (string | PackageCore.Style | object);

			calendar?: Self.GanttChart.Id;

			children?: globalThis.Array<Self.GanttChart.ResourceDefinition>;

		}

		interface TaskDefinition {
			id: Self.GanttChart.Id;

			parentId?: Self.GanttChart.Id;

			startDate: PackageCore.Date;

			endDate?: PackageCore.Date;

			type?: Self.GanttChart.TaskType;

			color?: (Self.GanttChart.TaskColor | Self.GanttChart.TaskCustomColor | PackageCore.Color);

			percentDone?: number;

			resizable?: boolean;

			draggable?: boolean;

			baselines?: globalThis.Array<Self.GanttChart.BaselineDefinition>;

			label?: (string | Self.GanttChart.TaskLabelCallback);

			style?: (string | PackageCore.Style | object);

		}

		interface BaselineDefinition {
			id: Self.GanttChart.Id;

			startDate: PackageCore.Date;

			endDate?: PackageCore.Date;

			color?: PackageCore.Color;

			style?: (string | PackageCore.Style | object);

		}

		interface AssignmentDefinition {
			id: Self.GanttChart.Id;

			resourceId: Self.GanttChart.Id;

			taskId: Self.GanttChart.Id;

		}

		interface DependencyDefinition {
			id: Self.GanttChart.Id;

			fromTask: Self.GanttChart.Id;

			toTask: Self.GanttChart.Id;

			fromSide?: Self.GanttChart.TaskSide;

			toSide?: Self.GanttChart.TaskSide;

			bidirectional?: boolean;

		}

		interface CalendarDefinition {
			id: Self.GanttChart.Id;

			intervals: globalThis.Array<Self.GanttChart.CalendarIntervalDefinition>;

		}

		interface CalendarIntervalDefinition {
			id: Self.GanttChart.Id;

			startDate?: PackageCore.Date;

			endDate?: PackageCore.Date;

			style?: (string | PackageCore.Style);

			tooltip?: (string | PackageCore.JSX.Element);

			content?: (string | Self.GanttChart.CalendarIntervalContentCallback);

		}

		type ColumnLabelCallback = (args: Self.GanttChart.ColumnLabelCallbackArgs) => (string | PackageCore.JSX.Element);

		interface ColumnLabelCallbackArgs {
			column: Self.GanttChart.ColumnDefinition;

		}

		type ResourceLabelCallback = (args: Self.GanttChart.ResourceLabelCallbackArgs) => (string | PackageCore.JSX.Element);

		interface ResourceLabelCallbackArgs {
			resource: Self.GanttChart.ResourceDefinition;

			column: Self.GanttChart.ColumnDefinition;

		}

		type ResourceTooltipCallback = (args: Self.GanttChart.ResourceTooltipCallbackArgs) => (string | PackageCore.JSX.Element | null);

		interface ResourceTooltipCallbackArgs {
			column: Self.GanttChart.ColumnDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		interface TaskCustomColor {
			color: PackageCore.Color;

			done?: PackageCore.Color;

		}

		type TaskColorCallback = (args: Self.GanttChart.TaskColorCallbackArgs) => (Self.GanttChart.TaskColor | Self.GanttChart.TaskCustomColor | PackageCore.Color | null);

		interface TaskColorCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type TaskLabelCallback = (args: Self.GanttChart.TaskLabelCallbackArgs) => (string | number | PackageCore.JSX.Element);

		interface TaskLabelCallbackArgs {
			resource: Self.GanttChart.ResourceDefinition;

			task: Self.GanttChart.TaskDefinition;

		}

		type TaskOuterLabelCallback = (args: Self.GanttChart.TaskOuterLabelCallbackArgs) => Self.GanttChart.TaskOuterLabelConfig;

		interface TaskOuterLabelCallbackArgs {
			resource: Self.GanttChart.ResourceDefinition;

			task: Self.GanttChart.TaskDefinition;

		}

		interface TaskOuterLabelConfig {
			before?: (string | number | PackageCore.JSX.Element);

			after?: (string | number | PackageCore.JSX.Element);

			above?: (string | number | PackageCore.JSX.Element);

			below?: (string | number | PackageCore.JSX.Element);

		}

		type ResourceClickCallback = (args: Self.GanttChart.ResourceClickCallbackArgs) => (boolean | void);

		interface ResourceClickCallbackArgs {
			column: Self.GanttChart.ColumnDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type TaskClickCallback = (args: Self.GanttChart.TaskClickCallbackArgs) => (boolean | void);

		interface TaskClickCallbackArgs {
			resource: Self.GanttChart.ResourceDefinition;

			task: Self.GanttChart.TaskDefinition;

		}

		type TaskContextMenuCallback = (args: Self.GanttChart.TaskContextMenuArgs) => (Self.GanttChart.TaskContextMenuDefinition | null);

		interface TaskContextMenuArgs {
			resource: Self.GanttChart.ResourceDefinition;

			task: Self.GanttChart.TaskDefinition;

		}

		interface TaskContextMenuDefinition {
			items: (globalThis.Array<Self.MenuItem.ItemDefinition> | null);

		}

		type TaskTooltipCallback = (args: Self.GanttChart.TaskTooltipCallbackArgs) => (string | PackageCore.JSX.Element | null);

		interface TaskTooltipCallbackArgs {
			resource: Self.GanttChart.ResourceDefinition;

			task: Self.GanttChart.TaskDefinition;

		}

		type TaskStyleCallback = (args: Self.GanttChart.TaskStyleCallbackArgs) => (string | PackageCore.Style | object | null);

		interface TaskStyleCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type ResourceStyleCallback = (args: Self.GanttChart.ResourceStyleCallbackArgs) => (string | PackageCore.Style | object | null);

		interface ResourceStyleCallbackArgs {
			column: Self.GanttChart.ColumnDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type TaskPositionCallback = (args: Self.GanttChart.TaskPositionCallbackArgs) => Self.GanttChart.TaskPositionCallbackResult;

		interface TaskPositionCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		interface TaskPositionCallbackResult {
			top: number;

			height: number;

		}

		type DragTaskPositionCallback = (args: Self.GanttChart.DragTaskPositionCallbackArgs) => Self.GanttChart.DragTaskPositionCallbackResult;

		interface DragTaskPositionCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

			startDate: PackageCore.Date;

			endDate: PackageCore.Date;

		}

		interface DragTaskPositionCallbackResult {
			top: number;

			height: number;

		}

		type ResourceExpandedCallback = (args: Self.GanttChart.ResourceExpandedCallbackArgs) => void;

		interface ResourceExpandedCallbackArgs {
			resource: Self.GanttChart.ResourceDefinition;

			expanded: boolean;

		}

		type TaskResizedCallback = (args: Self.GanttChart.TaskResizedCallbackArgs) => void;

		interface TaskResizedCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			previousTask: Self.GanttChart.TaskDefinition;

			startDate: PackageCore.Date;

			previousStartDate: PackageCore.Date;

			endDate: PackageCore.Date;

			previousEndDate: PackageCore.Date;

		}

		type TaskMovedCallback = (args: Self.GanttChart.TaskMovedCallbackArgs) => void;

		interface TaskMovedCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			previousTask: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

			previousResource: Self.GanttChart.ResourceDefinition;

			startDate: PackageCore.Date;

			previousStartDate: PackageCore.Date;

			endDate: PackageCore.Date;

			previousEndDate: PackageCore.Date;

		}

		type BaselineColorCallback = (args: Self.GanttChart.BaselineColorCallbackArgs) => (PackageCore.Color | null);

		interface BaselineColorCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			baseline: Self.GanttChart.BaselineDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type BaselineStyleCallback = (args: Self.GanttChart.BaselineStyleCallbackArgs) => (string | PackageCore.Style | object | null);

		interface BaselineStyleCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			baseline: Self.GanttChart.BaselineDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type BaselineTooltipCallback = (args: Self.GanttChart.BaselineTooltipCallbackArgs) => (string | PackageCore.JSX.Element | null);

		interface BaselineTooltipCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			baseline: Self.GanttChart.BaselineDefinition;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type TaskDropPlaceholderUpdateCallback = (args: Self.GanttChart.TaskDropPlaceholderUpdateCallbackArgs) => void;

		interface TaskDropPlaceholderUpdateCallbackArgs {
			placeholder: (Self.GanttChart.DropPlaceholder | null);

		}

		interface DropPlaceholder {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

			startDate: PackageCore.Date;

			endDate: PackageCore.Date;

		}

		interface ViewPresetConfig {
			tickWidth: number;

			rowHeight?: number;

			timelines: globalThis.Array<Self.GanttChart.TimelineConfig>;

			timeResolution?: Self.GanttChart.TimeResolutionConfig;

		}

		interface TimelineConfig {
			unit: Self.GanttChart.TimelineUnit;

			alignment?: Self.GanttChart.LabelAlignment;

			height?: number;

			label: (string | Self.GanttChart.TimelineLabelCallback);

		}

		type TimelineLabelCallback = (args: Self.GanttChart.TimelineLabelCallbackArgs) => (string | PackageCore.JSX.Element);

		interface TimelineLabelCallbackArgs {
			unit: Self.GanttChart.TimelineUnit;

			startDate: PackageCore.Date;

			i18n: PackageCore.I18n;

			formatService: PackageCore.FormatService;

			firstDayOfWeek: number;

		}

		type TimelineTooltipCallback = (args: Self.GanttChart.TimelineTooltipCallbackArgs) => (string | PackageCore.JSX.Element | null);

		interface TimelineTooltipCallbackArgs {
			unit: Self.GanttChart.TimelineUnit;

			startDate: PackageCore.Date;

			i18n: PackageCore.I18n;

			formatService: PackageCore.FormatService;

			firstDayOfWeek: number;

		}

		type TaskResizeTooltipCallback = (args: Self.GanttChart.TaskResizeTooltipCallbackArgs) => (string | PackageCore.JSX.Element | null);

		interface TaskResizeTooltipCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

			startDate: PackageCore.Date;

			endDate: PackageCore.Date;

		}

		type TaskResizeValidatorCallback = (args: Self.GanttChart.TaskResizeTooltipCallbackArgs) => boolean;

		interface TaskResizeValidatorCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

			startDate: PackageCore.Date;

			endDate: PackageCore.Date;

		}

		type TaskDragTooltipCallback = (args: Self.GanttChart.TaskDragTooltipCallbackArgs) => (string | PackageCore.JSX.Element | null);

		interface TaskDragTooltipCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			resource: Self.GanttChart.ResourceDefinition;

			startDate: PackageCore.Date;

			endDate: PackageCore.Date;

		}

		interface TimeResolutionConfig {
			unit: Self.GanttChart.TimelineUnit;

			increment: number;

		}

		type GridColumnContentCallback = (args: Self.GanttChart.GridColumnContentCallbackArgs) => (string | PackageCore.Style | PackageCore.JSX.Element | null);

		interface GridColumnContentCallbackArgs {
			startDate: PackageCore.Date;

		}

		type GridRowContentCallback = (args: Self.GanttChart.GridRowContentCallbackArgs) => (string | PackageCore.Style | PackageCore.JSX.Element | null);

		interface GridRowContentCallbackArgs {
			resource: Self.GanttChart.ResourceDefinition;

		}

		interface TimeRange {
			id: Self.GanttChart.Id;

			startDate: PackageCore.Date;

			endDate?: PackageCore.Date;

			headerStyle?: (string | PackageCore.Style);

			headerTooltip?: (string | PackageCore.JSX.Element);

			headerContent?: (string | PackageCore.JSX.Element | Self.GanttChart.TimeRangeContentCallback);

			bodyStyle?: (string | PackageCore.Style);

			bodyTooltip?: (string | PackageCore.JSX.Element);

			bodyContent?: (string | PackageCore.JSX.Element | Self.GanttChart.TimeRangeContentCallback);

		}

		type TimeRangeContentCallback = (args: Self.GanttChart.TimeRangeContentCallbackArgs) => PackageCore.JSX.Element;

		interface TimeRangeContentCallbackArgs {
			range: Self.GanttChart.TimeRange;

		}

		interface ResourceTimeRange {
			id: Self.GanttChart.Id;

			resourceId: Self.GanttChart.Id;

			startDate: PackageCore.Date;

			endDate: PackageCore.Date;

			style?: (string | PackageCore.Style);

			tooltip?: (string | PackageCore.JSX.Element);

			content?: (string | PackageCore.JSX.Element | Self.GanttChart.ResourceTimeRangeContentCallback);

		}

		type ResourceTimeRangeContentCallback = (args: Self.GanttChart.ResourceTimeRangeContentCallbackArgs) => PackageCore.JSX.Element;

		interface ResourceTimeRangeContentCallbackArgs {
			range: Self.GanttChart.ResourceTimeRange;

			resource: Self.GanttChart.ResourceDefinition;

		}

		type CalendarIntervalContentCallback = (args: Self.GanttChart.CalendarIntervalContentCallbackArgs) => PackageCore.JSX.Element;

		interface CalendarIntervalContentCallbackArgs {
			interval: Self.GanttChart.CalendarIntervalDefinition;

			resource?: Self.GanttChart.ResourceDefinition;

		}

		type DropValidatorCallback = (args: Self.GanttChart.DropValidatorCallbackArgs) => (boolean | Self.GanttChart.DropValidatorCallbackResult);

		interface DropValidatorCallbackArgs {
			task: Self.GanttChart.TaskDefinition;

			sourceResource: Self.GanttChart.ResourceDefinition;

			targetResource: Self.GanttChart.ResourceDefinition;

			sourceStartDate: PackageCore.Date;

			targetStartDate: PackageCore.Date;

			sourceEndDate: PackageCore.Date;

			targetEndDate: PackageCore.Date;

		}

		interface DropValidatorCallbackResult {
			resourceId?: Self.GanttChart.Id;

			startDate?: PackageCore.Date;

			endDate?: PackageCore.Date;

		}

		enum ColumnRegion {
			START,
			END,
		}

		export import ColumnType = Self.GanttConstant.ColumnType;

		export import LabelAlignment = Self.GanttConstant.LabelAlignment;

		export import ViewPreset = Self.GanttConstant.ViewPreset;

		export import TimelineLabel = Self.GanttTimelineLabel;

		enum GridLines {
			NONE,
			HORIZONTAL,
			VERTICAL,
			BOTH,
		}

		export import TaskColor = Self.GanttConstant.TaskColor;

		export import TimelineUnit = Self.GanttConstant.TimelineUnit;

		export import TaskType = Self.GanttConstant.TaskType;

		export import TaskSide = Self.GanttConstant.TaskSide;

		export import TaskLabelLocation = Self.GanttConstant.TaskLabelLocation;

		export import ScrollToMode = PackageCore.ScrollController.ScrollToMode;

	}

	namespace GanttConstant {
		enum ColumnType {
			DEFAULT,
			ROW_NUMBER,
			TREE,
		}

		enum LabelAlignment {
			START,
			CENTER,
			END,
		}

		enum ViewPreset {
			DAY_HOUR,
			WEEK_DAY,
			WEEK_DAY_HOUR,
			MONTH_DAY,
			MONTH_DAY_HOUR,
			MONTH_WEEK,
			MONTH_WEEK_DAY,
			YEAR_MONTH,
			YEAR_MONTH_WEEK,
		}

		enum TimelineUnit {
			YEAR,
			MONTH,
			WEEK,
			DAY,
			HOUR,
			MINUTE,
			SECOND,
			MILLISECOND,
		}

		enum TaskColor {
			NEUTRAL,
			SUCCESS,
			WARNING,
			DANGER,
			INFO,
			TEAL,
			ORANGE,
			TURQUOISE,
			TAUPE,
			GREEN,
			PINK,
			BROWN,
			LILAC,
			YELLOW,
			PURPLE,
			BLUE,
			PINE,
			THEMED,
			RED,
		}

		enum TaskType {
			LEAF,
			PARENT,
			MILESTONE,
		}

		enum TaskSide {
			TOP,
			BOTTOM,
			START,
			END,
		}

		enum TaskLabelLocation {
			ABOVE,
			BELOW,
			BEFORE,
			AFTER,
		}

	}

	export namespace GanttTimelineLabel {
		function dateFormat(args: {format: string}): Self.GanttChart.TimelineLabelCallback;

		function hour(args?: object): Self.GanttChart.TimelineLabelCallback;

		function dayName(args?: {short?: boolean}): Self.GanttChart.TimelineLabelCallback;

		function dayLetter(args?: object): Self.GanttChart.TimelineLabelCallback;

		function dayNameWithDate(args?: {short?: boolean; dateFormat?: string}): Self.GanttChart.TimelineLabelCallback;

		function dayNumber(args?: object): Self.GanttChart.TimelineLabelCallback;

		function weekDateRange(args?: object): Self.GanttChart.TimelineLabelCallback;

		function weekNumber(args?: object): Self.GanttChart.TimelineLabelCallback;

	}

	export enum GapSize {
		NONE,
		XXXXS,
		XXXS,
		XXS,
		XS,
		S,
		M,
		L,
		XL,
		XXL,
		XXXL,
		XXXXL,
		SPACING1X,
		SPACING2X,
		SPACING3X,
		SPACING4X,
		SPACING5X,
		SPACING6X,
		SPACING7X,
		SPACING8X,
		SPACING9X,
		SPACING10X,
		SPACING11X,
		SPACING12X,
		SMALL,
		MEDIUM,
		LARGE,
	}

	namespace GapSizeHelper {
		interface SizeObject {
			top: (Self.GapSize | null);

			bottom: (Self.GapSize | null);

			start: (Self.GapSize | null);

			end: (Self.GapSize | null);

			horizontal: (Self.GapSize | null);

			vertical: (Self.GapSize | null);

		}

		interface SizeDefinition {
			top: Self.GapSize;

			bottom: Self.GapSize;

			start: Self.GapSize;

			end: Self.GapSize;

		}

		interface SizeClassObject {
			top: Self.GapSizeHelper.SideClassObject;

			bottom: Self.GapSizeHelper.SideClassObject;

			start: Self.GapSizeHelper.SideClassObject;

			end: Self.GapSizeHelper.SideClassObject;

		}

		interface SideClassObject {
			xxxxs: PackageCore.Style;

			xxxs: PackageCore.Style;

			xxs: PackageCore.Style;

			xs: PackageCore.Style;

			s: PackageCore.Style;

			m: PackageCore.Style;

			l: PackageCore.Style;

			xl: PackageCore.Style;

			xxl: PackageCore.Style;

			xxxl: PackageCore.Style;

			xxxxl: PackageCore.Style;

			small: PackageCore.Style;

			medium: PackageCore.Style;

			large: PackageCore.Style;

		}

		enum CssProperty {
			PADDING,
			MARGIN,
		}

		enum Side {
			TOP,
			BOTTOM,
			START,
			END,
		}

		function parseGapSize(gapSize?: (Self.GapSizeHelper.SizeObject | Self.GapSize)): Self.GapSizeHelper.SizeDefinition;

		function getGapClasses(property: Self.GapSizeHelper.SizeClassObject, value: (Self.GapSizeHelper.SizeObject | Self.GapSize)): globalThis.Array<PackageCore.Style>;

		function generateGapClasses(cssProperty: Self.GapSizeHelper.CssProperty, tokens: object): Self.GapSizeHelper.SizeClassObject;

		function generateGapSideClass(cssProperty: Self.GapSizeHelper.CssProperty, side: Self.GapSizeHelper.Side, tokens: object): Self.GapSizeHelper.SideClassObject;

		function getGapDataAttributes(value: Self.GapSizeHelper.SizeObject): string;

		function GapSizeType(gapEnum: object, gapEnumName?: string): PackageCore.Type.Matcher;

	}

	export class GrabCell extends Self.GridCell {
		constructor();

		showDirtyFlag: boolean;

		showLineNumber: boolean;

		resizable: boolean;

		effectiveResizable: boolean;

		updateLineNumber(): void;

		updateDirtyFlag(): void;

		setResizable(value: boolean): void;

	}

	export namespace GrabCell {
	}

	export class GrabColumn extends Self.GridColumn {
		constructor(options: Self.GrabColumn.Options);

		showDirtyFlag: boolean;

		showLineNumber: boolean;

	}

	export namespace GrabColumn {
		interface Options extends Self.GridColumn.Options {
			showDirtyFlag?: boolean;

			showLineNumber?: boolean;

		}

		export import Cell = Self.GrabCell;

	}

	export interface GridBindingController {
		bindRow(row: Self.GridDataRow, options: object): void;

		unbindRow(row: Self.GridDataRow, options: object): void;

		commitRow(row: Self.GridDataRow, options: object): void;

		rollbackRow(row: Self.GridDataRow, options: object): void;

		reloadRow(row: Self.GridDataRow, options: object): void;

		reloadCell(row: Self.GridDataRow, options: object): void;

		getCellParameters(row: Self.GridDataRow, column: Self.GridColumn): void;

		handleCellUpdate(update: object): void;

		updateBindings(rootColumn: Self.GridColumn): void;

	}

	export namespace GridBindingController {
	}

	class GridBindingControllerWithCache extends Self.GridObservingBindingController {
	}

	namespace GridBindingControllerWithCache {
	}

	export class GridCell extends PackageCore.Component {
		constructor(options: Self.GridCell.Options);

		value: any;

		row: Self.GridRow;

		column: Self.GridColumn;

		dataGrid: Self.DataGrid;

		userData: object;

		rowOverlap: number;

		columnOverlap: number;

		inputMode: Self.GridCell.InputMode;

		editMode: boolean;

		editOnly: boolean;

		editable: boolean;

		effectiveEditable: boolean;

		immediateUpdate: boolean;

		effectiveImmediateUpdate: boolean;

		dirty: boolean;

		renderData: (object | null);

		draggable: boolean;

		effectiveDraggable: boolean;

		cursor: boolean;

		horizontalAlignment: Self.GridColumn.HorizontalAlignment;

		verticalAlignment: Self.GridColumn.VerticalAlignment;

		comparator: (((left: any, right: any) => boolean) | null);

		validator: (Self.GridCell.ValidatorCallback | null);

		content: (PackageCore.Component | null);

		viewContent: (PackageCore.Component | null);

		editContent: (PackageCore.Component | null);

		physicalIndex: (number | null);

		informativeIcon: (Self.Image | null);

		showStatusIcon: boolean;

		effectiveShowStatusIcon: boolean;

		helperButtons: globalThis.Array<Self.Button>;

		showRangeResizer: boolean;

		activate(scrollIntoView: boolean): void;

		acceptChanges(): void;

		discardChanges(): void;

		refresh(): void;

		reload(): void;

		setValue(value: any, options?: {discardChanges?: boolean; reason?: string}): void;

		setEditable(value: boolean): void;

		setDraggable(value: boolean): void;

		setCursor(value: boolean): void;

		setImmediateUpdate(value: boolean): void;

		setDirty(dirty: boolean, options?: {reason?: string}): void;

		setEditMode(editMode: boolean, options?: {reason?: string}): void;

		setHorizontalAlignment(value: Self.GridCell.HorizontalAlignment): void;

		setVerticalAlignment(value: Self.GridCell.VerticalAlignment): void;

		setPhysicalIndex(index: (number | null)): void;

		setPhysicalPosition(first: boolean, last: boolean): void;

		setColumnOverlap(columnOverlap: number): void;

		setInformativeIcon(icon: (Self.Image | null)): void;

		setHelperButtons(definition: (globalThis.Array<Self.GridCell.HelperButton> | globalThis.Array<Self.Button>)): void;

		setShowRangeResizer(value: boolean): void;

		compareValues(oldValue: any, newValue: any): boolean;

		validateValue(args?: {currentValue?: any; newValue?: any; reason?: any}): Self.GridCell.ValidationResult;

		autoSize(options?: {width?: boolean; height?: boolean}): void;

		autoSizeWidth(): void;

		createOverlay(options: object): Self.GridOverlay;

		layout(layout: {left: number; width: number; height: number}): void;

		getCopyValue(): string;

		protected _renderView(): void;

		protected _renderEdit(): void;

		protected _eraseView(): void;

		protected _eraseEdit(): void;

		protected _updateView(): void;

		protected _updateEdit(): void;

		static Event: Self.GridCell.EventTypes;

		static RefProperty: string;

	}

	export namespace GridCell {
		interface Options extends PackageCore.Component.Options {
			row: Self.GridRow;

			column: Self.GridColumn;

			rowOverlap?: number;

			userData?: object;

			value?: any;

			horizontalAlignment?: Self.GridCell.HorizontalAlignment;

			verticalAlignment?: Self.GridCell.VerticalAlignment;

			inputMode?: Self.DataGrid.InputMode;

			comparator?: (left: any, right: any) => boolean;

			dirty?: boolean;

			draggable?: boolean;

			editable?: boolean;

			immediateUpdate?: boolean;

			editMode?: boolean;

			icon?: Self.Image;

			showStatusIcon?: boolean;

			helperButtons?: (globalThis.Array<Self.GridCell.HelperButton> | globalThis.Array<Self.Button>);

			showHelperButtonsInViewMode?: boolean;

		}

		type WidgetOptionsCallback<T> = (args: {cell: Self.GridCell; external: boolean; columnOptions: T}) => T;

		type ValidatorCallback = (args: {cell: Self.GridCell; currentValue: any; newValue: any}, reason: string, setValid: Self.GridCell.SetValidCallback, discardChanges: () => void, reject: () => void) => void;

		type SetValidCallback = (valid: boolean, options?: {message?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element); reason?: string}) => void;

		interface EventTypes extends PackageCore.Component.EventTypes {
			VALUE_CHANGED: string;

			DIRTY_CHANGED: string;

			MODE_CHANGED: string;

			EFFECTIVE_DRAGGABLE_CHANGED: string;

			EFFECTIVE_EDITABLE_CHANGED: string;

		}

		interface HelperButton {
			icon: Self.Image.Source;

			label: (string | PackageCore.Translation);

			action: Self.Button.ActionCallback;

		}

		interface ValidationResult {
			status: Self.GridCell.Status;

			message: (undefined | null | string | PackageCore.Translation);

			reject: boolean;

		}

		export import InputMode = Self.GridConstants.InputMode;

		export import Status = PackageCore.Component.Status;

		enum ValueChangeReason {
			ACCEPT,
			INPUT,
		}

		export import VerticalAlignment = Self.GridConstants.VerticalAlignment;

		export import HorizontalAlignment = Self.GridConstants.HorizontalAlignment;

	}

	class GridCellRange {
		constructor(startCell: Self.GridCell, endCell: Self.GridCell);

		start: Self.GridCell;

		end: Self.GridCell;

		dragStart: (Self.GridCell | null);

		equals(range: (Self.GridCellRange | null)): boolean;

		visit(callback: Self.GridCellRange.VisitCallback): void;

	}

	namespace GridCellRange {
		type VisitCallback = (cell: Self.GridCell, args: {rowIndex: number; columnIndex: number; startRow: boolean; endRow: boolean; startColumn: boolean; endColumn: boolean}) => void;

	}

	export class GridColumn implements PackageCore.EventSource {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options: Self.GridColumn.Options);

		type: Self.DataGrid.ColumnType;

		name: string;

		userData: object;

		width: number;

		minWidth: number;

		maxWidth: number;

		manualWidth: boolean;

		stretchFactor: number;

		stretchable: boolean;

		effectiveStretchable: boolean;

		visible: boolean;

		effectiveVisible: boolean;

		draggable: boolean;

		effectiveDraggable: boolean;

		resizable: boolean;

		effectiveResizable: boolean;

		editable: boolean;

		effectiveEditable: boolean;

		immediateUpdate: boolean;

		level: number;

		label: (string | PackageCore.Translation);

		binding: (string | object);

		binder: object;

		index: number;

		section: Self.DataGrid.ColumnSection;

		physicalIndex: number;

		parentColumn: (Self.GridColumn | null);

		rootColumn: Self.GridColumn;

		childColumns: globalThis.Array<Self.GridColumn>;

		childCount: number;

		visibleChildColumns: globalThis.Array<Self.GridColumn>;

		dataGrid: Self.DataGrid;

		horizontalAlignment: Self.GridColumn.HorizontalAlignment;

		verticalAlignment: Self.GridColumn.VerticalAlignment;

		headerHorizontalAlignment: Self.GridColumn.HorizontalAlignment;

		headerVerticalAlignment: Self.GridColumn.VerticalAlignment;

		classList: PackageCore.HtmlClassList;

		headerClassList: PackageCore.HtmlClassList;

		leafCount: number;

		visibleLeafCount: number;

		leaf: boolean;

		effectiveLeaf: boolean;

		enabled: boolean;

		effectiveEnabled: boolean;

		headerCell: Self.GridHeaderCell;

		userMinWidth: number;

		userMaxWidth: number;

		sortable: boolean;

		effectiveSortable: boolean;

		sortDirection: (Self.DataGrid.SortDirection | null);

		sortOrder: (number | null);

		sortDefault: boolean;

		menu: (globalThis.Array<object> | ((column: Self.GridColumn) => globalThis.Array<object>));

		inputMode: Self.GridColumn.InputMode;

		comparator: (((left: any, right: any) => boolean) | null);

		validator: (Self.GridCell.ValidatorCallback | null);

		showStatusIcon: boolean;

		helperButtons: (Self.GridColumn.HelperButtonProvider | null);

		helperButtonMode: Self.GridColumn.HelperButtonMode;

		headerHelperButtons: (globalThis.Array<Self.Button> | globalThis.Array<Self.GridCell.HelperButton>);

		headerHelperButtonMode: Self.GridColumn.HelperButtonMode;

		mandatory: boolean;

		searchable: boolean;

		searchPredicate: (Self.GridColumn.SearchPredicateCallback | null);

		sortComparatorProvider: (Self.GridColumn.SortComparatorProviderCallback | null);

		visibility: (Self.GridColumn.VisibilityBreakpoint | null);

		createCell(args: object): Self.GridCell;

		createHeaderCell(args: any): Self.GridHeaderCell;

		refreshCells(): void;

		reloadCells(): void;

		addColumn(columnDefinition: (Self.DataGrid.ColumnDefinition | Self.GridColumn), options?: {index?: number; reason?: string}): Self.GridColumn;

		addColumns(columnDefinitions: (globalThis.Array<Self.DataGrid.ColumnDefinition> | globalThis.Array<Self.GridColumn>), options?: {index?: number; reason?: string}): globalThis.Array<Self.GridColumn>;

		removeColumn(id: (string | Self.GridColumn), options?: {reason?: string}): Self.GridColumn;

		removeColumns(index: number, count: number, options?: {reason?: string}): globalThis.Array<Self.GridColumn>;

		removeAll(options?: {reason?: string}): globalThis.Array<Self.GridColumn>;

		moveColumn(columnId: (string | Self.GridColumn), targetParent: Self.GridColumn, options?: {index?: number; reason?: string}): Self.GridColumn;

		moveColumns(index: number, count: number, targetParent: Self.GridColumn, options?: {index?: number; reason?: string}): globalThis.Array<Self.GridColumn>;

		findColumn(id: (string | number | ((column: Self.GridColumn) => boolean) | Self.GridColumn), deep?: boolean): (Self.GridColumn | null);

		setVisible(visible: boolean): void;

		setEnabled(value: boolean): void;

		setEditable(value: boolean): void;

		setDraggable(value: boolean): void;

		setResizable(value: boolean): void;

		setSortable(value: boolean): void;

		setImmediateUpdate(value: boolean): void;

		setLabel(label: (string | PackageCore.Translation)): void;

		setWidth(width: number, args?: {reason?: string}): void;

		setHorizontalAlignment(value: Self.GridColumn.HorizontalAlignment): void;

		setVerticalAlignment(value: Self.GridColumn.HorizontalAlignment): void;

		setHeaderHorizontalAlignment(value: Self.GridColumn.HorizontalAlignment): void;

		setHeaderVerticalAlignment(value: Self.GridColumn.HorizontalAlignment): void;

		setHeaderHelperButtons(buttons: (globalThis.Array<Self.Button> | globalThis.Array<Self.GridCell.HelperButton>)): void;

		getFlatColumns(): globalThis.Array<Self.GridColumn>;

		getLeafColumns(): globalThis.Array<Self.GridColumn>;

		getVisibleLeafColumns(): globalThis.Array<Self.GridColumn>;

		visit(callback: (column: Self.GridColumn) => (boolean | null), self?: boolean): void;

		visitUp(callback: (column: Self.GridColumn) => (boolean | null)): void;

		visitCells(callback: (cell: Self.GridCell) => void): void;

		visitDataCells(callback: (cell: Self.GridCell) => void): void;

		unboxValue(row: Self.GridRow, value: any): any;

		boxValue(row: Self.GridRow, value: any): any;

		autoSize(options?: {width?: boolean; height?: boolean}): void;

		autoSizeWidth(): void;

		createOverlay(options: object): Self.GridOverlay;

		setSortDirection(direction: Self.DataGrid.SortDirection, options?: {reason?: string}): void;

		setSortOrder(order: number, options?: {reason?: string}): void;

		setSortDefault(value: boolean, options?: {reason?: string}): void;

		setMenu(menu: (globalThis.Array<object> | ((column: Self.GridColumn) => globalThis.Array<object>))): void;

		private _onCreateCell(args: object): Self.GridCell;

		static registerColumnFactory(type: string, factory: {createInstance: (options: object) => Self.GridColumn}): void;

		static getColumnFactory(type: string): void;

		static instantiateColumn(type: string, args: Self.GridColumn.Options): Self.GridColumn;

		static defaultComparator(cell: Self.GridCell, oldValue: any, newValue: any): boolean;

		static Event: Self.GridColumn.EventTypes;

	}

	export namespace GridColumn {
		interface Options {
			type: Self.DataGrid.ColumnType;

			name: string;

			binding?: (string | object);

			label?: (string | PackageCore.Translation);

			dataGrid?: Self.DataGrid;

			userData?: object;

			width?: number;

			stretchFactor?: number;

			level?: number;

			horizontalAlignment?: Self.GridColumn.HorizontalAlignment;

			verticalAlignment?: Self.GridColumn.VerticalAlignment;

			headerHorizontalAlignment?: Self.GridColumn.HorizontalAlignment;

			headerVerticalAlignment?: Self.GridColumn.VerticalAlignment;

			minWidth?: number;

			maxWidth?: number;

			userMinWidth?: number;

			userMaxWidth?: number;

			sortable?: boolean;

			sortDirection?: Self.DataGrid.SortDirection;

			sortOrder?: number;

			sortDefault?: boolean;

			inputMode?: Self.DataGrid.InputMode;

			menu?: (globalThis.Array<object> | ((column: Self.GridColumn) => globalThis.Array<object>));

			comparator?: (left: any, right: any) => boolean;

			validator?: Self.GridCell.ValidatorCallback;

			customizeCell?: Self.GridColumn.CustomizeCellCallback;

			customizeHeaderCell?: (cell: Self.GridHeaderCell) => void;

			messageFilter?: PackageCore.RoutedMessage.Filter;

			boxValue?: (row: Self.GridDataRow, value: any) => any;

			unboxValue?: (row: Self.GridDataRow, value: any) => any;

			headerContent?: Self.GridHeaderCell.ContentCallback;

			visible?: boolean;

			draggable?: boolean;

			resizable?: boolean;

			editable?: boolean;

			enabled?: boolean;

			immediateUpdate?: boolean;

			classList?: (string | globalThis.Array<string>);

			headerClassList?: (string | globalThis.Array<string>);

			columns?: (globalThis.Array<Self.DataGrid.ColumnDefinition> | globalThis.Array<Self.GridColumn>);

			showStatusIcon?: boolean;

			helperButtons?: Self.GridColumn.HelperButtonProvider;

			helperButtonMode?: boolean;

			headerHelperButtons?: (globalThis.Array<Self.Button> | globalThis.Array<Self.GridCell.HelperButton>);

			headerHelperButtonMode?: boolean;

			searchable?: boolean;

			searchPredicate?: Self.GridColumn.SearchPredicateCallback;

			sortComparatorProvider?: Self.GridColumn.SortComparatorProviderCallback;

			visibility?: Self.GridColumn.VisibilityBreakpoint;

			on?: PackageCore.EventSource.ListenerMap;

		}

		type WidgetOptionsCallback<T> = (args: {cell: Self.GridCell; external: boolean; columnOptions: T}) => T;

		type HelperButtonProvider = (cell: Self.GridCell) => (globalThis.Array<Self.GridCell.HelperButton> | globalThis.Array<Self.Button>);

		type SearchPredicateCallback = (args: Self.GridColumn.SearchPredicateCallbackArgs) => boolean;

		interface SearchPredicateCallbackArgs {
			column: Self.GridColumn;

			dataItem: any;

			value: any;

			phrase: string;

		}

		type SortComparatorProviderCallback = (args: Self.GridColumn.SortComparatorProviderCallbackArgs) => PackageCore.Comparator.Function;

		interface SortComparatorProviderCallbackArgs {
			column: Self.GridColumn;

			direction: Self.GridColumn.SortDirection;

		}

		type CustomizeCellCallback = (cell: Self.GridCell, args: Self.GridColumn.CustomizeCellCallbackArgs) => void;

		interface CustomizeCellCallbackArgs {
			column: Self.GridColumn;

			row: Self.GridDataRow;

		}

		interface EventTypes {
			COLUMNS_ADDED: string;

			COLUMNS_REMOVED: string;

			COLUMNS_MOVED: string;

			RESIZED: string;

			SHOWN: string;

			EFFECTIVE_ENABLED_CHANGED: string;

			EFFECTIVE_EDITABLE_CHANGED: string;

			CLASS_LIST_CHANGED: string;

			LABEL_CHANGED: string;

			SORT_DIRECTION_CHANGED: string;

			SORT_ORDER_CHANGED: string;

			SORT_DEFAULT_CHANGED: string;

			CELL_UPDATE: string;

		}

		export import InputMode = Self.GridConstants.InputMode;

		export import HelperButtonMode = Self.GridConstants.HelperButtonMode;

		export import VerticalAlignment = Self.GridConstants.VerticalAlignment;

		export import HorizontalAlignment = Self.GridConstants.HorizontalAlignment;

		export import SortDirection = Self.GridConstants.SortDirection;

		enum VisibilityBreakpoint {
			XX_SMALL,
			X_SMALL,
			SMALL,
			MEDIUM,
			LARGE,
			X_LARGE,
		}

		enum Width {
			AUTO,
			DEFAULT,
		}

	}

	export namespace GridColumnDataExchange {
	}

	class GridColumnFactory {
		constructor();

		registerColumn(type: string, factory: {createInstance: (options: object) => Self.GridColumn}): void;

		getFactory(type: string): {createInstance: (options: object) => Self.GridColumn};

		instantiateColumn(type: string, args: object): (Self.GridColumn | null);

		clear(): void;

	}

	namespace GridColumnFactory {
	}

	namespace GridConstants {
		enum RowSection {
			HEADER,
			BODY,
			FOOTER,
		}

		enum ColumnSection {
			LEFT,
			BODY,
			RIGHT,
		}

		enum InputMode {
			DEFAULT,
			EDIT_ONLY,
		}

		enum HelperButtonMode {
			EDIT_ONLY,
			VIEW_ONLY,
			ALWAYS,
		}

		enum HorizontalAlignment {
			LEFT,
			CENTER,
			RIGHT,
			STRETCH,
		}

		enum VerticalAlignment {
			TOP,
			CENTER,
			BOTTOM,
			STRETCH,
		}

		enum SortDirection {
			NONE,
			ASCENDING,
			DESCENDING,
		}

		enum ColumnType {
			ACTION,
			CHECK_BOX,
			DROPDOWN,
			DATE_PICKER,
			TIME_PICKER,
			GRAB,
			LINK,
			TEMPLATED,
			TEXT_AREA,
			TEXT_BOX,
			TREE,
			DETAIL,
			MULTI_SELECT_DROPDOWN,
			SELECTION,
		}

		enum CursorUpdateReason {
			CALL,
			KEYPRESS,
			CLICK,
		}

	}

	export namespace GridDataExchange {
		export import Column = Self.GridColumnDataExchange;

		export import Row = Self.GridRowDataExchange;

	}

	export class GridDataRow extends Self.GridMasterRow {
		constructor(options?: Self.GridDataRow.Options);

		dataStoreEntry: PackageCore.DataStoreEntry;

		dataItem: any;

		dataBound: boolean;

		loaded: boolean;

		loading: boolean;

		dirty: boolean;

		childRowHint: (boolean | null);

		commit(options: {reason?: string}): void;

		rollback(options: {reason?: string}): void;

		setDirty(dirty: boolean, options?: {reason?: string}): void;

		attachDataItemListener(observedItem: any, listener: (args: PackageCore.PropertyObservable.EventArgs, sender: any) => void): void;

		detachDataItemListener(): void;

		load(): globalThis.Promise<any>;

		loadAll(): globalThis.Promise<any>;

		expandAll(): globalThis.Promise<any>;

		static Event: Self.GridDataRow.EventTypes;

	}

	export namespace GridDataRow {
		interface Options extends Self.GridMasterRow.Options {
		}

		interface EventTypes extends Self.GridMasterRow.EventTypes {
			COMMITTED: string;

			ROLLBACKED: string;

			DIRTY_CHANGED: string;

			LOADING_STARTED: string;

			LOADING_FINISHED: string;

		}

	}

	export class GridHeaderCell extends Self.GridCell {
		constructor(options?: Self.GridHeaderCell.Options);

		label: (string | PackageCore.Translation);

		mandatory: boolean;

		sortable: boolean;

		sortDirection: (Self.DataGrid.SortDirection | null);

		sortOrder: (number | null);

		sortDefault: boolean;

		resizable: boolean;

		effectiveResizable: boolean;

		verticalAlignment: Self.GridColumn.VerticalAlignment;

		horizontalAlignment: Self.GridColumn.HorizontalAlignment;

		validator: (Self.GridCell.ValidatorCallback | null);

		setLabel(label: (string | PackageCore.Translation)): void;

		setMandatory(value: boolean): void;

		setSortable(sortable: boolean): void;

		setSortDirection(direction: Self.DataGrid.SortDirection): void;

		setSortOrder(order: number): void;

		setSortDefault(value: boolean): void;

		setResizable(value: boolean): void;

	}

	export namespace GridHeaderCell {
		interface Options extends Self.GridCell.Options {
			label?: (string | PackageCore.Translation);

			sortDirection?: Self.DataGrid.SortDirection;

			sortOrder?: number;

			sortDefault?: boolean;

			autoSizeHeight?: boolean;

			mandatory?: boolean;

			sortable?: boolean;

			resizable?: boolean;

			content?: Self.GridHeaderCell.ContentCallback;

		}

		type ContentCallback = (args: {cell: Self.GridHeaderCell; context: object}) => (PackageCore.Component | PackageCore.JSX.Element);

	}

	export class GridHeaderRow extends Self.GridSyntheticRow {
		constructor(options?: Self.GridHeaderRow.Options);

	}

	export namespace GridHeaderRow {
		interface Options extends Self.GridSyntheticRow.Options {
		}

	}

	export interface GridInputController {
		attach(component: PackageCore.Component): void;

		detach(): void;

		reset(): void;

		filterMessage(message: object, result: object): void;

		handleMessage(message: object, result: object): void;

		editCell(cell: Self.GridCell, activate: boolean, reason?: Self.DataGrid.CursorUpdateReason): void;

		startEditing(cell: Self.GridCell, activate?: boolean, reason?: Self.DataGrid.CursorUpdateReason): void;

		closeEditing(focusGrid: boolean, nextEditedCell?: Self.GridCell): void;

		acceptChanges(): void;

		discardChanges(): void;

		handleRowRemoved(row: Self.GridRow): void;

	}

	export namespace GridInputController {
	}

	class GridManualAutoSize {
		constructor();

	}

	namespace GridManualAutoSize {
	}

	export class GridMasterRow extends Self.GridRow {
		constructor(options?: Self.GridMasterRow.Options);

		index: number;

		childRows: globalThis.Array<Self.GridRow>;

		childCount: number;

		expanded: boolean;

		collapsed: boolean;

		insideAboveSyntheticRows: globalThis.Array<Self.GridSyntheticRow>;

		insideBelowSyntheticRows: globalThis.Array<Self.GridSyntheticRow>;

		outsideAboveSyntheticRows: globalThis.Array<Self.GridSyntheticRow>;

		outsideBelowSyntheticRows: globalThis.Array<Self.GridSyntheticRow>;

		hasDetailRow: boolean;

		detailRow: (Self.GridSyntheticRow | null);

		detailVisible: boolean;

		firstPhysicalRowSetRow: Self.GridRow;

		lastPhysicalRowSetRow: Self.GridRow;

		hasPreviousRow: boolean;

		hasNextRow: boolean;

		pinned: boolean;

		addRow(row: Self.GridDataRow, options?: {index?: number; reason?: string}): Self.GridRow;

		addRows(rows: globalThis.Array<Self.GridDataRow>, options?: {index?: number; previousIndex?: number; reason?: string}): void;

		removeRow(row: Self.GridDataRow, options?: {reason?: string}): Self.GridRow;

		removeRows(index: number, count?: number, options?: {reason?: string}): Self.GridRow;

		removeAll(options?: {reason?: string}): void;

		addSyntheticRow(row: Self.GridSyntheticRow, options?: {inside?: boolean; above?: boolean; order?: number; reason?: string}): void;

		removeSyntheticRow(row: Self.GridSyntheticRow, options?: {reason?: string}): void;

		getSyntheticRows(inside: boolean, above: boolean): globalThis.Array<Self.GridSyntheticRow>;

		setDetailRow(row: (Self.GridSyntheticRow | null)): void;

		showDetailRow(value: boolean, options?: {reason?: string}): void;

		toggleDetailRow(): void;

		setExpanded(value: boolean, options: {reason?: string}): void;

		expand(): void;

		collapse(): void;

		visit(callback: (row: Self.GridRow) => (boolean | null), self?: boolean): void;

		visitRowSet(callback: (row: Self.GridRow) => void): void;

		containsRow(row: Self.GridMasterRow): boolean;

		createRowSetOverlay(options: object): Self.GridOverlay;

		static Event: Self.GridMasterRow.EventTypes;

	}

	export namespace GridMasterRow {
		interface Options extends Self.GridRow.Options {
			index?: number;

			expanded?: boolean;

		}

		interface EventTypes extends Self.GridRow.EventTypes {
			ROWS_ADDED: string;

			ROWS_REMOVED: string;

			EXPANDED: string;

			SYNTHETIC_ROW_ADDED: string;

			SYNTHETIC_ROW_REMOVED: string;

			DETAIL_ROW_TOGGLED: string;

		}

	}

	export class GridMultiSelection implements Self.GridSelection {
		constructor(options: object);

		selectedItems: globalThis.Array<any>;

		select(item: any, value: boolean): Self.GridMultiSelection;

		selectAll(items: globalThis.Array<any>, value: boolean): Self.GridMultiSelection;

		isSelected(item: any): boolean;

		static of(items: globalThis.Array<any>): Self.GridMultiSelection;

		static EMPTY: Self.GridMultiSelection;

	}

	export namespace GridMultiSelection {
	}

	class GridMultiSelectionStrategy implements Self.GridSelectionStrategy {
		constructor(options: object);

	}

	namespace GridMultiSelectionStrategy {
	}

	class GridObservingBindingController implements Self.GridBindingController {
		bindRow(row: Self.GridDataRow, options: object): void;

		unbindRow(row: Self.GridDataRow, options: object): void;

		commitRow(row: Self.GridDataRow, options: object): void;

		rollbackRow(row: Self.GridDataRow, options: object): void;

		reloadRow(row: Self.GridDataRow, options: object): void;

		reloadCell(row: Self.GridDataRow, options: object): void;

		getCellParameters(row: Self.GridDataRow, column: Self.GridColumn): void;

		handleCellUpdate(update: object): void;

		updateBindings(rootColumn: Self.GridColumn): void;

	}

	namespace GridObservingBindingController {
	}

	class GridOverlay {
	}

	namespace GridOverlay {
	}

	export class GridPanel extends PackageCore.Component {
		constructor(options?: Self.GridPanel.Options);

		items: globalThis.Array<Self.GridPanelItem>;

		components: globalThis.Array<PackageCore.Component>;

		children: PackageCore.VDom.Children;

		length: number;

		empty: boolean;

		rows: (number | string | globalThis.Array<string>);

		columns: (number | string | globalThis.Array<string>);

		areas: globalThis.Array<Self.GridPanelArea>;

		rowGap: Self.GridPanel.GapSize;

		columnGap: Self.GridPanel.GapSize;

		outerGap: (Self.GridPanel.GapSize | Self.GridPanel.GapSizeObject);

		defaultRowHeight: string;

		defaultColumnWidth: string;

		autoFlow: string;

		decorator: (PackageCore.Decorator | null);

		element: Self.GridPanel.Element;

		defaultItemOptions: Self.GridPanel.ItemProps;

		add(component: (Self.GridPanel.ItemConfiguration | globalThis.Array<Self.GridPanel.ItemConfiguration>)): Self.GridPanel;

		remove(componentOrIndex: (PackageCore.Component | number | globalThis.Array<(PackageCore.Component | number)>)): Self.GridPanel;

		move(args: {component: PackageCore.Component; area?: (string | Self.GridPanelArea.Options | Self.GridPanelArea); index?: number; reason?: string}): Self.GridPanel;

		clear(): Self.GridPanel;

		replace(currentComponent: PackageCore.Component, newComponent: PackageCore.Component): Self.GridPanel;

		has(component: PackageCore.Component): boolean;

		itemForComponent(component: PackageCore.Component): Self.GridPanelItem;

		itemAtIndex(index: number): Self.GridPanelItem;

		getRowHeight(rowIndex: number): string;

		setRowHeight(rowIndex: number, rowHeight?: string): Self.GridPanel;

		getColumnWidth(columnIndex: number): string;

		setColumnWidth(columnIndex: number, columnWidth?: string): Self.GridPanel;

		setRowGap(value: Self.GridPanel.GapSize): void;

		setColumnGap(value: Self.GridPanel.GapSize): void;

		setOuterGap(value: Self.GridPanel.GapSize): void;

		addArea(area: (Self.GridPanelArea | object)): void;

		removeArea(area: (Self.GridPanelArea | string)): void;

		hasArea(name: string): boolean;

		getArea(name: string): Self.GridPanelArea;

		setAutoFlow(value: string): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		static Event: Self.GridPanel.EventTypes;

		static Item(props?: Self.GridPanel.JsxItemProps): PackageCore.JSX.Element;

	}

	export namespace GridPanel {
		interface BaseItemProps {
			alignment?: Self.GridPanel.Alignment;

			justification?: Self.GridPanel.Justification;

			area?: (string | Self.GridPanelArea);

			columnIndex?: (number | null);

			columnSpan?: number;

			rowIndex?: (number | null);

			rowSpan?: number;

			horizontalShrink?: boolean;

			verticalShrink?: boolean;

		}

		interface ItemProps extends Self.GridPanel.BaseItemProps {
		}

		interface JsxItemProps extends Self.GridPanel.BaseItemProps {
			children?: PackageCore.VDom.Children;

			key?: any;

		}

		interface StructuredItemConfiguration {
			component: PackageCore.Component;

			options?: Self.GridPanel.ItemProps;

		}

		interface FlatItemConfiguration extends Self.GridPanel.ItemProps {
			component: PackageCore.Component;

		}

		type ItemConfiguration = (PackageCore.Component | Self.GridPanel.StructuredItemConfiguration | Self.GridPanel.FlatItemConfiguration);

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ADDED: string;

			ITEM_REMOVED: string;

			ITEM_MOVED: string;

		}

		interface GapSizeObject {
			top?: Self.GridPanel.GapSize;

			bottom?: Self.GridPanel.GapSize;

			start?: Self.GridPanel.GapSize;

			end?: Self.GridPanel.GapSize;

			horizontal?: Self.GridPanel.GapSize;

			vertical?: Self.GridPanel.GapSize;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			areas?: globalThis.Array<(Self.GridPanelArea | Self.GridPanelArea.Options)>;

			autoFlow?: AutoFlow;

			columns?: (number | string | globalThis.Array<string>);

			decorator?: PackageCore.Decorator;

			defaultColumnWidth?: string;

			defaultItemOptions?: Self.GridPanel.ItemProps;

			defaultRowHeight?: string;

			items?: (Self.GridPanel.ItemConfiguration | globalThis.Array<Self.GridPanel.ItemConfiguration>);

			outerGap?: (Self.GridPanel.GapSize | Self.GridPanel.GapSizeObject);

			columnGap?: Self.GridPanel.GapSize;

			rowGap?: Self.GridPanel.GapSize;

			gap?: Self.GridPanel.GapSize;

			element?: Self.GridPanel.Element;

			rows?: (number | string | globalThis.Array<string>);

		}

		export import Justification = Self.GridPanelItem.Justification;

		export import Alignment = Self.GridPanelItem.Alignment;

		export import GapSize = Self.GapSize;

		enum AutoFlow {
			ROW,
			ROW_DENSE,
			COLUMN,
			COLUMN_DENSE,
		}

		enum VisualStyle {
			BLOCK,
			INLINE,
		}

		export import Decorator = PackageCore.Decorator;

		export import Element = PackageCore.Html.Element.Section;

	}

	export class GridPanelArea {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options: Self.GridPanelArea.Options);

		name: (string | null);

		rowIndex: (number | null);

		columnIndex: (number | null);

		rowSpan: number;

		columnSpan: number;

		setRowIndex(rowIndex: number): void;

		setColumnIndex(columnIndex: number): void;

		setRowSpan(rowSpan: number): void;

		setColumnSpan(columnSpan: number): void;

		static from(definition: (Self.GridPanelArea.Options | Self.GridPanelArea)): Self.GridPanelArea;

	}

	export namespace GridPanelArea {
		interface Options {
			name: string;

			columnIndex?: (number | null);

			columnSpan?: number;

			rowIndex?: (number | null);

			rowSpan?: number;

		}

	}

	export class GridPanelItem {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options: Self.GridPanelItem.Options);

		component: PackageCore.Component;

		rowIndex: number;

		columnIndex: number;

		rowSpan: number;

		columnSpan: number;

		justification: Self.GridPanelItem.Justification;

		alignment: Self.GridPanelItem.Alignment;

		verticalShrink: boolean;

		horizontalShrink: boolean;

		area: Self.GridPanelArea;

		setRowIndex(rowIndex: number): void;

		setColumnIndex(columnIndex: number): void;

		setRowSpan(rowSpan: number): void;

		setColumnSpan(columnSpan: number): void;

		setJustification(justification: Self.GridPanelItem.Justification): void;

		setAlignment(alignment: Self.GridPanelItem.Alignment): void;

		setVerticalShrink(verticalShrink: boolean): void;

		setHorizontalShrink(horizontalShrink: boolean): void;

		setArea(area: Self.GridPanelArea): void;

		static Event: Self.GridPanelItem.EventTypes;

	}

	export namespace GridPanelItem {
		interface Options {
			component: PackageCore.Component;

			alignment?: Self.GridPanelItem.Alignment;

			area: Self.GridPanelArea;

			horizontalShrink?: boolean;

			justification?: Self.GridPanel.Justification;

			verticalShrink?: boolean;

		}

		interface EventTypes {
			POSITION_CHANGED: string;

		}

		enum Justification {
			START,
			CENTER,
			END,
			STRETCH,
		}

		enum Alignment {
			START,
			CENTER,
			END,
			STRETCH,
		}

	}

	export class GridPortlet extends PackageCore.Component {
		constructor(options?: Self.GridPortlet.Options);

	}

	export namespace GridPortlet {
		interface Options extends PackageCore.Component.Options {
		}

	}

	class GridRangeSelectionFilter implements PackageCore.MessageHandler {
		constructor(options: {dispatcher: PackageCore.PageMessageDispatcher; dataGrid: Self.DataGrid; cell: Self.GridCell; selecting: boolean});

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

	}

	namespace GridRangeSelectionFilter {
	}

	class GridRangeSelectionRemovalFilter implements PackageCore.MessageHandler {
		constructor(options: {dispatcher: PackageCore.PageMessageDispatcher; dataGrid: Self.DataGrid});

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

	}

	namespace GridRangeSelectionRemovalFilter {
	}

	class GridResizer extends PackageCore.Component {
		constructor(options?: Self.GridResizer.Options);

	}

	namespace GridResizer {
		interface Options extends PackageCore.Component.Options {
			orientation?: Self.GridResizer.Orientation;

			startResize?: (position: object) => void;

		}

		enum Orientation {
			HORIZONTAL,
			VERTICAL,
		}

	}

	export class GridRow implements PackageCore.EventSource {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options: Self.GridRow.Options);

		guid: string;

		section: Self.DataGrid.RowSection;

		physicalIndex: (number | null);

		userData: object;

		enabled: boolean;

		effectiveEnabled: boolean;

		draggable: boolean;

		effectiveDraggable: boolean;

		resizable: boolean;

		effectiveResizable: boolean;

		editable: boolean;

		effectiveEditable: boolean;

		dataGrid: (Self.DataGrid | null);

		height: (number | null);

		heightType: Self.GridRow.Height;

		minHeight: number;

		maxHeight: number;

		manualHeight: boolean;

		parentRow: (Self.GridRow | null);

		cells: globalThis.Map<Self.GridColumn, Self.GridCell>;

		level: number;

		valid: boolean;

		status: Self.GridRow.Status;

		showBorder: boolean;

		cellConfiguration: (row: Self.GridRow, column: Self.GridColumn) => (Self.GridCell | null);

		rootAttributes: PackageCore.HtmlAttributeList;

		classList: PackageCore.HtmlClassList;

		cellLayout: {left: globalThis.Array<Self.GridRow.CellLayout>; body: globalThis.Array<Self.GridRow.CellLayout>; right: globalThis.Array<Self.GridRow.CellLayout>};

		segment: {left: Self.GridRowSegment; body: Self.GridRowSegment; right: Self.GridRowSegment};

		type: Self.GridRow.Type;

		visitUp(callback: (row: Self.GridRow) => (boolean | null)): void;

		getCell(column: (Self.GridColumn | string)): (Self.GridCell | null);

		refresh(): void;

		reload(options: object): void;

		reloadCell(cell: Self.GridCell): void;

		setEnabled(enabled: boolean): void;

		setEditable(value: boolean): void;

		setResizable(value: boolean): void;

		setDraggable(value: boolean): void;

		setShowBorder(value: boolean): void;

		setValid(valid: boolean, options?: {reason?: string}): void;

		setStatus(status: Self.GridRow.Status, options?: {reason?: string}): void;

		setHeight(value: number, args?: {reason?: string}): void;

		autoSize(options?: {width?: boolean; height?: boolean}): void;

		autoSizeWidth(): void;

		applyAutoHeight(): void;

		createOverlay(options: object): Self.GridOverlay;

		openAllCellsForEditing(): void;

		closeAllCellsFromEditing(): void;

		findFirstCell(args?: {predicate?: (cell: Self.GridCell) => boolean}): (Self.GridCell | null);

		findLastCell(args?: {predicate?: (cell: Self.GridCell) => boolean}): (Self.GridCell | null);

		lazyUpdateCell(column: (string | Self.GridColumn), callback: (cell: Self.GridCell) => void): void;

		createSegment(columnSection: Self.DataGrid.ColumnSection): void;

		disposeSegment(columnSection: Self.DataGrid.ColumnSection): void;

		setPhysicalIndex(value: (number | null)): void;

		static Event: Self.GridRow.EventTypes;

	}

	export namespace GridRow {
		interface Options {
			dataGrid: Self.DataGrid;

			parentRow?: Self.GridRow;

			level?: number;

			userData?: object;

			status?: Self.GridRow.Status;

			cellConfiguration: (row: Self.GridRow, column: Self.GridColumn) => (Self.GridCell | null);

			height?: (number | Self.GridRow.Height);

			showBorder?: boolean;

			draggable?: boolean;

			resizable?: boolean;

			editable?: boolean;

			enabled?: boolean;

			classList?: (string | globalThis.Array<string>);

			rootAttributes?: object;

			section?: Self.DataGrid.RowSection;

			on?: PackageCore.EventSource.ListenerMap;

		}

		interface EventTypes {
			RESIZED: string;

			STATUS_CHANGED: string;

			ENABLED_CHANGED: string;

			EFFECTIVE_ENABLED_CHANGED: string;

		}

		interface CellLayout {
			empty?: boolean;

			cell?: Self.GridCell;

			id: number;

		}

		export import Status = PackageCore.Component.Status;

		enum Attribute {
			ROW_ID,
			PARENT_ROW_ID,
			MASTER_ROW_ID,
		}

		enum Type {
			ROW,
			DATA,
			SYNTHETIC,
			HEADER,
		}

		enum Height {
			AUTO,
			FIXED,
			DEFAULT,
		}

	}

	export namespace GridRowDataExchange {
	}

	/**
	 * @deprecated
	 */
	class GridRowEditInputController extends Self.GridSelectEditInputController implements Self.GridInputController {
		constructor();

	}

	namespace GridRowEditInputController {
	}

	class GridRowSegment extends PackageCore.Component {
		constructor(options?: Self.GridRowSegment.Options);

	}

	namespace GridRowSegment {
		interface Options extends PackageCore.Component.Options {
		}

	}

	class GridSegment extends PackageCore.Component {
		constructor();

		virtualization: boolean;

		planUpdate(): void;

	}

	namespace GridSegment {
	}

	class GridSelectEditInputController implements Self.GridInputController {
		constructor(options: Self.GridSelectEditInputController.Options);

		attach(component: PackageCore.Component): void;

		detach(): void;

		reset(): void;

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

		handleRowRemoved(row: Self.GridRow): void;

		editCell(cell: Self.GridCell, activate: boolean, reason: Self.DataGrid.CursorUpdateReason): void;

		startEditing(cell: Self.GridCell, activate?: boolean, reason?: Self.DataGrid.CursorUpdateReason): void;

		closeEditing(focusGrid: boolean, nextEditedCell?: Self.GridCell): void;

		acceptChanges(): void;

		discardChanges(): void;

		filterMessage(message: object, result: object): void;

		handleMessage(message: object, result: object): void;

		private _moveRowDown(row: Self.GridDataRow): void;

	}

	namespace GridSelectEditInputController {
		interface Options {
			editingMode?: boolean;

			beforeEditCell?: Self.GridSelectEditInputController.BeforeEditCellCallback;

		}

		type BeforeEditCellCallback = (args: {cell: Self.GridCell; reason: string}) => void;

	}

	export interface GridSelection {
		select(item: any, value: boolean): Self.GridSelection;

		isSelected(item: any): boolean;

	}

	export namespace GridSelection {
		enum Mode {
			ALL,
			PAGE,
		}

		enum ChangeReason {
			SELECTION_UPDATE,
			SELECT_ALL,
		}

	}

	interface GridSelectionStrategy {
	}

	namespace GridSelectionStrategy {
	}

	export class GridSingleSelection implements Self.GridSelection {
		constructor(options: object);

		selectedItem: globalThis.Array<any>;

		select(item: any, value: boolean): Self.GridSingleSelection;

		selectAll(items: globalThis.Array<any>, value: boolean): Self.GridSingleSelection;

		isSelected(item: any): boolean;

		static of(item: any): Self.GridSingleSelection;

		static EMPTY: Self.GridSingleSelection;

	}

	export namespace GridSingleSelection {
	}

	class GridSingleSelectionStrategy implements Self.GridSelectionStrategy {
		constructor();

	}

	namespace GridSingleSelectionStrategy {
	}

	export class GridSyntheticCell extends Self.GridCell {
		constructor(options?: Self.GridSyntheticCell.Options);

	}

	export namespace GridSyntheticCell {
		interface Options extends Self.GridCell.Options {
			content: (Self.GridSyntheticCell.ContentCallback | PackageCore.JSX.Element | PackageCore.Component);

			copyValueProvider?: (cell: Self.GridSyntheticCell) => (string | Element);

		}

		type ContentCallback = (args: {cell: Self.GridSyntheticCell; context: object}) => (PackageCore.Component | PackageCore.JSX.Element);

	}

	export class GridSyntheticRow extends Self.GridRow {
		constructor(options?: Self.GridSyntheticRow.Options);

		masterRow: Self.GridDataRow;

		order: number;

		inside: boolean;

		above: boolean;

	}

	export namespace GridSyntheticRow {
		interface Options extends Self.GridRow.Options {
		}

	}

	namespace GridTask {
	}

	class GridView extends PackageCore.Component {
		constructor();

		rowCount: {header: number; body: number; footer: number};

		rowSize: PackageCore.StaticSizeIndex;

		columnCount: {left: number; body: number; right: number};

		columnSize: PackageCore.StaticSizeIndex;

		viewportSize: {x: number; y: number};

		bodyViewportSize: PackageCore.Scrollable.Size;

		bodyContentSize: PackageCore.Scrollable.Size;

		scrollController: PackageCore.ScrollController;

		scrollOffset: {x: number; y: number};

		scrollability: PackageCore.Scrollable.Scrollability;

		stickySegments: {left: boolean; right: boolean; header: boolean; footer: boolean};

		stickyScrollbars: {horizontal: boolean; vertical: boolean};

		hasPendingUpdates: boolean;

		virtualization: boolean;

		dataLoader: (Self.Loader | null);

		actionBar: (PackageCore.Component | PackageCore.VDomElement | null);

		actionBarHeight: (number | null);

		actionBarVisible: boolean;

		stickyActionBar: boolean;

		placeholder: (PackageCore.Component | PackageCore.VDomElement | null);

		placeholderVisible: boolean;

		static Event: Self.GridView.EventTypes;

	}

	namespace GridView {
		interface EventTypes extends PackageCore.Component.EventTypes {
			WILL_SCHEDULE_UPDATE: string;

			DID_SCHEDULE_UPDATE: string;

			WILL_UPDATE: string;

			DID_UPDATE: string;

			VIEWPORT_RESIZE: string;

			SCROLLABILITY_CHANGED: string;

		}

	}

	export class Group extends PackageCore.Component {
		constructor(options?: Self.Group.Options);

		content: PackageCore.Component;

		setContent(content: PackageCore.Component): void;

	}

	export namespace Group {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: PackageCore.Component;

			role?: Self.Group.Role;

		}

		enum Role {
			GROUP,
			RADIO_GROUP,
		}

	}

	export class GrowlMessage extends PackageCore.Component {
		constructor(options: Self.GrowlMessage.Options);

		title: (string | PackageCore.Translation);

		content: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		children: PackageCore.VDom.Children;

		type: Self.GrowlMessage.Type;

		icon: Self.Image.Source;

		showCloseButton: boolean;

		closeOnClick: boolean;

		expanded: boolean;

		close(): void;

		static Event: Self.GrowlMessage.EventTypes;

	}

	export namespace GrowlMessage {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			title?: (string | PackageCore.Translation);

			content?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			icon?: Self.Image.Source;

			showCloseButton?: boolean;

			closeOnClick?: boolean;

			type?: Self.GrowlMessage.Type;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			CLOSING: string;

			CLOSED: string;

		}

		export import Type = PackageCore.UserMessageService.MessageType;

		enum I18n {
			COLLAPSE,
			CLOSE,
			EXPAND,
			INFO,
			SUCCESS,
			WARNING,
			ERROR,
		}

	}

	export class GrowlPanel extends PackageCore.Component {
		constructor(options?: Self.GrowlPanel.Options);

		position: (Self.GrowlPanel.Position | null);

		alignment: (Self.GrowlPanel.Alignment | null);

		messages: globalThis.Array<PackageCore.Component>;

		manual: boolean;

		add(message: (Self.GrowlMessage | globalThis.Array<Self.GrowlMessage>)): void;

		remove(message: Self.BannerMessage): void;

		clear(): void;

		setPosition(position: Self.GrowlPanel.Position): void;

		setAlignment(alignment: Self.GrowlPanel.Position): void;

		createUserMessage(message: PackageCore.UserMessageService.MessageOptions): Self.GrowlMessage;

		connect(service: PackageCore.UserMessageService): void;

		disconnect(): void;

	}

	export namespace GrowlPanel {
		interface Options extends PackageCore.Component.Options {
			messages?: globalThis.Array<Self.GrowlMessage>;

			position?: Self.GrowlPanel.Position;

			alignment?: Self.GrowlPanel.Alignment;

			manual?: boolean;

		}

		export import Position = Self.GrowlPanelOptions.Position;

		export import Alignment = Self.GrowlPanelOptions.Alignment;

	}

	namespace GrowlPanelOptions {
		enum Alignment {
			START,
			END,
		}

		enum Position {
			START,
			CENTER,
			END,
		}

	}

	export namespace HeaderNavigationEvent {
	}

	export class Heading extends PackageCore.Component {
		constructor(options?: Self.Heading.Options);

		content: Self.Heading.Content;

		children: PackageCore.VDom.Children;

		type: Self.Heading.Type;

		kind: (Self.Heading.Kind | null);

		weight: (Self.Heading.Weight | null);

		size: (Self.Heading.Size | null);

		level: (number | null);

		inline: boolean;

		setType(type: Self.Heading.Type): void;

		setKind(kind: (Self.Heading.Kind | null)): void;

		setWeight(weight: (Self.Heading.Weight | null)): void;

		setSize(size: (Self.Heading.Size | null)): void;

		setLevel(level: (number | null)): void;

		setContent(content: Self.Heading.Content): void;

		setInline(inline: boolean): void;

	}

	export namespace Heading {
		type Content = (null | string | number | PackageCore.Component | PackageCore.JSX.Element | PackageCore.Translation);

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: Self.Heading.Content;

			inline?: boolean;

			kind?: Self.Heading.Kind;

			level?: number;

			size?: Self.Heading.Size;

			type?: Self.Heading.Type;

			weight?: Self.Heading.Weight;

		}

		enum Type {
			PAGE_TITLE,
			PAGE_SUBTITLE,
			LARGE_HEADING,
			MEDIUM_HEADING,
			SMALL_HEADING,
		}

		enum Kind {
			PAGE,
			CONTENT,
		}

		enum Weight {
			DISPLAY,
			HEADING,
			SUBHEADING,
		}

		enum Size {
			XS,
			S,
			M,
			L,
			XL,
			XXL,
		}

		enum VisualStyle {
			STANDALONE,
			EMBEDDED,
		}

	}

	export class HelpCenterService {
		constructor(options?: Self.HelpCenterService.Options);

		setTopicId(topicId: string): void;

		openHelpTopic(taskId?: string): void;

	}

	export namespace HelpCenterService {
		interface Options {
			taskId?: string;

		}

	}

	export class HelpService {
		constructor(options?: Self.HelpService.Options);

		getFieldLevelHelp(options: Self.HelpService.FieldLevelHelpOptions & {owner: (PackageCore.Component | PackageCore.VDomRef)}): globalThis.Promise<Self.HelpService.FieldLevelHelp>;

	}

	export namespace HelpService {
		interface Options {
			showInternalId: boolean;

			taskId: string;

		}

		interface FieldLevelHelp {
			show: () => void;

		}

		interface FieldLevelHelpOptions {
			fieldId: string;

			parentId?: string;

			variantId?: string;

			isEdit?: boolean;

		}

	}

	class Host {
		constructor(options?: {root?: HTMLElement; context?: object});

		root: HTMLElement;

		running: boolean;

		context: object;

		run(options?: {waitDocumentReady?: boolean}): globalThis.Promise<any>;

		render(element: (PackageCore.Component | PackageCore.JSX.Element), container?: HTMLElement, options?: {contextPortal?: PackageCore.Component}): Self.Host.RootHandle;

		erase(): void;

		dispose(): void;

		getContext(type: string): any;

		setContext(type: (string | Record<string, any>), value: any): void;

		static page(options?: {context?: object}): Self.Host;

		static testPage(options?: {context?: object}): Self.Host;

		static context(types?: object): object;

		static testContext(types?: object): object;

	}

	namespace Host {
		interface RootHandle {
			render: (element: PackageCore.JSX.Element) => void;

			dispose: () => void;

		}

	}

	export class HtmlWrapper extends PackageCore.Component {
		constructor(options?: (Self.HtmlWrapper.ContentProvider | Self.HtmlWrapper.Options));

		content: Self.HtmlWrapper.ContentProvider;

		refresh(): void;

		static ofElement(element: HTMLElement, options?: Self.HtmlWrapper.Options): Self.HtmlWrapper;

		static ofVDom(element: PackageCore.JSX.Element, options?: Self.HtmlWrapper.Options): Self.HtmlWrapper;

		static ofHtmlString(string: string, options?: Self.HtmlWrapper.Options): Self.HtmlWrapper;

	}

	export namespace HtmlWrapper {
		type ContentProvider = () => (HTMLElement | PackageCore.JSX.Element | PackageCore.Component);

		interface Options extends PackageCore.Component.Options {
			content?: Self.HtmlWrapper.ContentProvider;

		}

	}

	export class IFrame extends PackageCore.Component {
		constructor(options?: Self.IFrame.Options);

		url: string;

		loaded: boolean;

		content: Self.Window;

		onLoad: Self.IFrame.LoadCallback;

		onUnload: Self.IFrame.UnloadCallback;

	}

	export namespace IFrame {
		interface Options extends PackageCore.Component.Options {
			url?: string;

			onLoad?: Self.IFrame.LoadCallback;

			onUnload?: Self.IFrame.UnloadCallback;

		}

		type LoadCallback = () => void;

		type UnloadCallback = () => void;

	}

	export class Image extends PackageCore.Component {
		constructor(options?: (Self.Image.Options | string | PackageCore.ImageMetadata));

		image: Self.Image.Source;

		presentation: boolean;

		scalable: boolean;

		size: Self.Image.SizeDefinition;

		borderRadius: Self.Image.BorderRadius;

		color: (Self.Image.Color | null);

		colorStrength: (Self.Image.ColorStrength | null);

		setImage(image: Self.Image.Source): void;

		setSize(size: Self.Image.SizeDefinition): void;

		setBorderRadius(borderRadius: Self.Image.BorderRadius): void;

		setPresentation(presentation: boolean): void;

		setScalable(scalable: boolean): void;

	}

	export namespace Image {
		interface SizeObject {
			height: (number | string);

			width: (number | string);

		}

		type SizeDefinition = (Self.Image.Size | Self.Image.SizeObject | string | number);

		type Source = (string | PackageCore.Url | PackageCore.ImageMetadata.Options | PackageCore.ImageMetadata);

		interface Options extends PackageCore.Component.Options {
			borderRadius?: Self.Image.BorderRadius;

			image: Self.Image.Source;

			presentation?: boolean;

			scalable?: boolean;

			size?: Self.Image.SizeDefinition;

			color?: Self.Image.Color;

			colorStrength?: Self.Image.ColorStrength;

		}

		export import Size = PackageCore.ImageConstant.Size;

		export import BorderRadius = PackageCore.ImageConstant.BorderRadius;

		export import Color = PackageCore.ImageConstant.Color;

		export import ColorStrength = PackageCore.ImageConstant.ColorStrength;

	}

	class InlineEditor extends PackageCore.Component {
		constructor(options: Self.InlineEditor.Options);

		isEditing: boolean;

		readOnly: boolean;

		text: (string | PackageCore.Translation);

		textValidator: (Self.InlineEditor.TextValidatorCallback | null);

		textBox: (Self.TextBox | null);

		invalidIcon: Self.Image;

		invalidIconOptions: object;

		startEditing(args?: object): void;

		finishEditing(args?: object): void;

		setText(text: (string | PackageCore.Translation), options?: object): void;

		private _validate(validator: (Self.InlineEditor.TextValidatorCallback | null), options: object): boolean;

		private _handleInputTextChanged(args: Self.TextBox.TextChangedArgs): void;

		private _handleInputValidityChanged(args: object): void;

		static Event: Self.InlineEditor.EventTypes;

	}

	namespace InlineEditor {
		interface Options extends PackageCore.Component.Options {
			acceptInvalidValue?: boolean;

			createLabel?: (args: {text: string}) => PackageCore.JSX.Element;

			inputSize?: (number | null);

			keyValidator?: Self.TextBox.KeyValidatorCallback;

			readOnly?: boolean;

			text?: string;

			textValidator?: Self.InlineEditor.TextValidatorCallback;

			invalidIconOptions?: object;

		}

		type TextValidatorCallback = (args: Self.InlineEditor.TextValidatorArgs) => boolean;

		interface TextValidatorArgs {
			text: string;

			previousText: string;

			reason: string;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TEXT_CHANGED: string;

			EDITING_STARTED: string;

			EDITING_FINISHED: string;

		}

		enum VisualStyle {
			EMBEDDED,
		}

		enum Reason {
			CALL,
			CANCEL,
			CLICK,
			KEY_ENTER,
			KEY_ESCAPE,
			FOCUS_OUT,
			TEXT_SYNC,
		}

	}

	export enum InputSize {
		AUTO,
		XXS,
		XS,
		S,
		M,
		L,
		XL,
		XXL,
	}

	export class Kpi extends PackageCore.Component {
		constructor(options?: Self.Kpi.Options);

		color: Self.Kpi.Color;

		title: (string | number | PackageCore.Translation);

		value: (string | number | PackageCore.Translation);

		trend: Self.Kpi.Trend;

		justification: Self.Kpi.Justification;

	}

	export namespace Kpi {
		interface Trend {
			value: (string | number | PackageCore.Translation);

			description: (string | number | PackageCore.Translation);

			direction: Self.Kpi.TrendDirection;

		}

		interface Options extends PackageCore.Component.Options {
			color?: Self.Kpi.Color;

			title?: (string | number | PackageCore.Translation);

			value?: (string | number | PackageCore.Translation);

			trend?: Self.Kpi.Trend;

			justification?: Self.Kpi.Justification;

		}

		enum Color {
			NONE,
			NEUTRAL,
			SUCCESS,
			WARNING,
			DANGER,
			INFO,
			TEAL,
			ORANGE,
			TURQUOISE,
			TAUPE,
			GREEN,
			PINK,
			BROWN,
			LILAC,
			YELLOW,
			PURPLE,
			BLUE,
			PINE,
			THEMED,
		}

		enum TrendDirection {
			POSITIVE,
			NEGATIVE,
		}

		enum Justification {
			START,
			CENTER,
			END,
		}

	}

	export class KpiPortlet extends PackageCore.Component {
		constructor(options?: Self.KpiPortlet.Options);

	}

	export namespace KpiPortlet {
		interface Options extends PackageCore.Component.Options {
		}

	}

	export class Label extends PackageCore.Component {
		constructor(options?: Self.Label.Options);

		label: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		children: PackageCore.VDom.Children;

		for: (PackageCore.Component | PackageCore.VDomRef | string);

		wrap: (boolean | number);

		whitespace: boolean;

		clickHandler: (Self.Label.ClickHandler | null);

		ellipsisHelper: Self.EllipsisTooltip;

		setLabel(label: (null | string | number | PackageCore.Translation | PackageCore.Component)): void;

		setFor(value: (PackageCore.Component | PackageCore.VDomRef | string)): void;

	}

	export namespace Label {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			clickHandler?: Self.Label.ClickHandler;

			for?: (string | PackageCore.VDomRef | PackageCore.Component);

			label?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			whitespace?: boolean;

			wrap?: (boolean | number);

		}

		type ClickHandler = (target: (PackageCore.Component | null), message: PackageCore.PointerMessage, label: Self.Label) => boolean;

		enum VisualStyle {
			STANDALONE,
			BUTTON,
			EMBEDDED,
			GRID_HEADER,
		}

	}

	export class LazyPanel extends PackageCore.Component {
		constructor(options?: Self.LazyPanel.Options);

		content: (PackageCore.Component | PackageCore.JSX.Element | null);

		element: Self.LazyPanel.Element;

		horizontalAlignment: Self.LazyPanel.HorizontalAlignment;

		verticalAlignment: Self.LazyPanel.VerticalAlignment;

		outerGap: (Self.LazyPanel.GapSize | Self.LazyPanel.GapSizeObject);

		decorator: (PackageCore.Decorator | null);

		children: PackageCore.VDom.Children;

		setContent(content: (PackageCore.Component | PackageCore.JSX.Element | null)): void;

		setHorizontalAlignment(value: Self.LazyPanel.HorizontalAlignment): void;

		setVerticalAlignment(value: Self.LazyPanel.VerticalAlignment): void;

		setOuterGap(value: Self.LazyPanel.GapSize): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

	}

	export namespace LazyPanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (Self.LazyPanel.ContentProvider | PackageCore.Component | PackageCore.JSX.Element);

			decorator?: PackageCore.Decorator;

			horizontalAlignment?: Self.LazyPanel.HorizontalAlignment;

			outerGap?: (Self.LazyPanel.GapSize | Self.LazyPanel.GapSizeObject);

			verticalAlignment?: Self.LazyPanel.VerticalAlignment;

			element?: Self.LazyPanel.Element;

		}

		type ContentProvider = (setContent: (content: (PackageCore.Component | PackageCore.JSX.Element)) => void) => (PackageCore.Component | PackageCore.JSX.Element | globalThis.Promise<(PackageCore.Component | PackageCore.JSX.Element)>);

		interface GapSizeObject {
			top?: Self.LazyPanel.GapSize;

			bottom?: Self.LazyPanel.GapSize;

			start?: Self.LazyPanel.GapSize;

			end?: Self.LazyPanel.GapSize;

			horizontal?: Self.LazyPanel.GapSize;

			vertical?: Self.LazyPanel.GapSize;

		}

		enum HorizontalAlignment {
			START,
			END,
			CENTER,
			STRETCH,
		}

		enum VerticalAlignment {
			START,
			END,
			CENTER,
			STRETCH,
		}

		export import GapSize = Self.GapSize;

		export import Decorator = PackageCore.Decorator;

		export import Element = PackageCore.Html.Element.Section;

	}

	export class Legend extends PackageCore.Component {
		constructor(options?: Self.Legend.Options);

		label: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		color: (Self.Legend.Color | PackageCore.Color | string);

		shape: Self.Legend.Shape;

		size: Self.Legend.Size;

	}

	export namespace Legend {
		interface Options extends PackageCore.Component.Options {
			label?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			color?: (Self.Legend.Color | PackageCore.Color | string);

			shape?: Self.Legend.Shape;

			wrap?: Self.Legend.Size;

		}

		enum Color {
			NEUTRAL,
			SUCCESS,
			WARNING,
			DANGER,
			INFO,
			TEAL,
			ORANGE,
			TURQUOISE,
			TAUPE,
			GREEN,
			PINK,
			BROWN,
			LILAC,
			YELLOW,
			PURPLE,
			BLUE,
			PINE,
			ERROR,
			LIGHT_BLUE,
		}

		enum Size {
			SMALL,
			MEDIUM,
			LARGE,
		}

		enum Shape {
			SQUARE,
			ROUNDED_SQUARE,
			CIRCLE,
		}

	}

	export class Link extends PackageCore.Component {
		constructor(options?: Self.Link.Options);

		content: (string | PackageCore.Translation | PackageCore.Component);

		children: PackageCore.VDom.Children;

		url: (string | PackageCore.Url | null);

		route: (string | PackageCore.Route | Self.Link.Route | null);

		target: (string | Self.Link.Target | null);

		download: (string | Self.Link.Download | null);

		wrap: (boolean | number);

		whitespace: boolean;

		setContent(content: (null | string | number | PackageCore.Translation | PackageCore.Component)): void;

		setUrl(url: string): void;

		setRoute(route: (string | PackageCore.Route | Self.Link.Route)): void;

		setTarget(target: (string | Self.Link.Target | null)): void;

		setDownload(download: (string | Self.Link.Download | null)): void;

		click(): void;

		static fromImage(linkOptions: Self.Link.Options, imageOptions: Self.Image.Options): void;

		static Event: Self.Link.EventTypes;

	}

	export namespace Link {
		interface Route {
			route: (string | PackageCore.Route);

			parameters?: object;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ACTION: string;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (string | number | PackageCore.Translation | PackageCore.Component | null);

			target?: Self.Link.Target;

			download?: (string | Self.Link.Download | null);

			url?: (string | PackageCore.Url);

			route?: (string | PackageCore.Route | Self.Link.Route);

			whitespace?: boolean;

			wrap?: (boolean | number);

		}

		enum VisualStyle {
			DEFAULT,
			MENU,
		}

		enum Target {
			BLANK,
			SELF,
			PARENT,
			TOP,
		}

		enum Download {
			FILENAME_BY_RESPONSE_HEADER,
		}

	}

	export class LinkCell extends Self.GridCell {
		constructor();

		link: (Self.Link | null);

		wrap: boolean;

		widgetOptions: (Self.Link.Options | Self.GridCell.WidgetOptionsCallback<Self.Link.Options>);

	}

	export namespace LinkCell {
	}

	export class LinkColumn extends Self.GridColumn {
		constructor(options: Self.LinkColumn);

		widgetOptions: (Self.Link.Options | Self.GridColumn.WidgetOptionsCallback<Self.Link.Options> | null);

		wrap: boolean;

	}

	export namespace LinkColumn {
		interface Options extends Self.GridColumn.Options {
			wrap?: boolean;

			widgetOptions?: (Self.Link.Options | Self.GridColumn.WidgetOptionsCallback<Self.Link.Options>);

		}

		export import Cell = Self.LinkCell;

	}

	export class LinkPortlet extends PackageCore.Component {
		constructor(options?: Self.LinkPortlet.Options);

	}

	export namespace LinkPortlet {
		interface Options extends PackageCore.Component.Options {
		}

	}

	export class List extends PackageCore.Component {
		constructor(options?: Self.List.Options);

		type: Self.List.Type;

		items: globalThis.Array<any>;

		children: PackageCore.VDom.Children;

		setType(type: Self.List.Type): void;

		setItems(items: globalThis.Array<any>): void;

		private _renderItems(): HTMLElement;

		static Ordered(props: Self.List.Options): PackageCore.JSX.Element;

		static Definition(props: Self.List.Options): PackageCore.JSX.Element;

		static Item(props: {children?: PackageCore.VDom.Children; classList?: (string | PackageCore.Style | globalThis.Array<(string | PackageCore.Style)>); rootStyle?: Record<string, string>; rootAttributes?: Record<string, string>; type?: Self.List.Type}): PackageCore.JSX.Element;

		static Term(props: {children?: PackageCore.VDom.Children; classList?: (string | PackageCore.Style | globalThis.Array<(string | PackageCore.Style)>); rootStyle?: Record<string, string>; rootAttributes?: Record<string, string>}): PackageCore.JSX.Element;

		static Details(props: {children?: PackageCore.VDom.Children; classList?: (string | PackageCore.Style | globalThis.Array<(string | PackageCore.Style)>); rootStyle?: Record<string, string>; rootAttributes?: Record<string, string>}): PackageCore.JSX.Element;

	}

	export namespace List {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items?: (globalThis.Array<any> | null);

			type?: Self.List.Type;

		}

		enum Type {
			UNORDERED,
			ORDERED,
			DEFINITION,
			NONE,
		}

		enum VisualStyle {
			STANDALONE,
			EMBEDDED,
		}

	}

	export class ListBox extends Self.DataSourceComponent {
		constructor(options?: Self.ListBox.Options);

		selectedItems: globalThis.Array<any>;

		selectedListItems: globalThis.Array<Self.ListItem>;

		selectedValues: globalThis.Array<any>;

		selectedIndexes: globalThis.Array<Self.ListBox.IndexPath>;

		selectable: boolean;

		selectableItems: globalThis.Array<Self.ListItem>;

		maxSelectedItemsCount: (number | null);

		draggable: boolean;

		showSelectionBar: boolean;

		showSelectedOnlyCheckbox: boolean;

		selectedOnly: boolean;

		multiSelect: boolean;

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		valueMember: (Self.DataSourceComponent.ValueMember | null);

		showCheckMarks: boolean;

		allowKeySearch: boolean;

		cursorItem: Self.ListItem;

		cursorVisibility: Self.ListBox.CursorVisibility;

		initialCursorPosition: Self.ListBox.InitialCursorPosition;

		moveSelectionWithCursor: boolean;

		items: globalThis.Array<Self.ListItem>;

		visibleItems: globalThis.Array<Self.ListItem>;

		empty: boolean;

		placeholder: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		virtualization: boolean;

		maxViewportHeight: number;

		stickyGroupHeaders: boolean;

		dropPlaceholder: Self.ListItem;

		dropPlaceholderIndex: (number | null);

		rootItem: Self.ListItem;

		itemContent: (((item: Self.ListItem, renderData: object) => (PackageCore.Component | PackageCore.JSX.Element)) | null);

		filterPredicate: ((() => boolean));

		onSelectionChanged: (Self.ListBox.SelectionChangedCallback | null);

		groupAutomationIdMember: (string | null);

		itemAtIndex(indexPath: Self.ListBox.IndexPath): (Self.ListItem | null);

		itemForElement(element: Element): (Self.ListItem | null);

		itemForDataItem(dataItem: any): (Self.ListItem | null);

		setCursorItem(item: (Self.ListItem | null), options?: object): void;

		setCursorVisibility(cursorVisibility: boolean): void;

		setItemContent(value: (((item: Self.ListItem, renderData: object) => (PackageCore.Component | PackageCore.JSX.Element)) | null)): void;

		select(options: {items?: globalThis.Array<any>; listItems?: globalThis.Array<Self.ListItem>; indexes?: globalThis.Array<any>; values?: globalThis.Array<any>; append?: boolean; unselect?: boolean; reason?: string}): void;

		unselect(options: object): void;

		selectAll(options: object): void;

		selectAllVisible(options: object): void;

		unselectAll(options: object): void;

		filter(predicate: any): void;

		scrollTo(args: object): void;

		scrollToSelection(): void;

		setSelectable(value: boolean, options: object): void;

		setMaxSelectedItemsCount(value: number): void;

		setDraggable(value: boolean, args: object): void;

		setMultiSelect(value: object): void;

		setShowSelectionBar(value: boolean): void;

		getNextSelectableItem(from: Self.ListItem, step: number, circular: boolean): (Self.ListItem | null);

		setPlaceholder(value: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element)): void;

		setDropPlaceholderIndex(index: number): void;

		visit(callback: (item: Self.ListItem) => (boolean | null)): void;

		private keySearch(message: object): boolean;

		static Event: Self.ListBox.EventTypes;

	}

	export namespace ListBox {
		type IndexPath = globalThis.Array<number>;

		interface Options extends Self.DataSourceComponent.Options {
			displayMember?: Self.DataSourceComponent.DisplayMember;

			valueMember?: Self.DataSourceComponent.ValueMember;

			groupAutomationIdMember?: string;

			itemDragSource?: PackageCore.DataExchange.DragSourceProvider;

			keepSelection?: boolean;

			moveSelectionWithCursor?: boolean;

			multiSelect?: boolean;

			placeholder?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			selectable?: boolean;

			draggable?: boolean;

			itemReorder?: boolean;

			selectedIndexes?: (number | globalThis.Array<number>);

			selectedItems?: any;

			selectedValues?: any;

			showCheckMarks?: boolean;

			withGroups?: boolean;

			stickyGroupHeaders?: boolean;

			itemContent?: (item: Self.ListItem, renderData: object) => (PackageCore.Component | PackageCore.JSX.Element);

			cursorVisibility?: Self.ListBox.CursorVisibility;

			onSelectionChanged?: Self.ListBox.SelectionChangedCallback;

			customizeItem?: Self.ListBox.CustomizeItemCallback;

			allowKeySearch?: boolean;

			circularSelection?: boolean;

			comparator?: Self.ListBox.ComparatorCallback;

			maxSelectedItemsCount?: number;

			initialCursorPosition?: Self.ListBox.InitialCursorPosition;

			itemHeight?: number;

			itemVisualStyle?: Self.ListItem.VisualStyle;

			groupVisualStyle?: Self.ListItem.VisualStyle;

			virtualization?: boolean;

			itemMatcher?: Self.ListBox.ItemMatcherCallback;

			showSelectionBar?: boolean;

			showSelectedOnlyCheckbox?: boolean;

			selectedOnly?: boolean;

			maxViewportHeight?: number;

		}

		type SelectionChangedCallback = (args: Self.ListBox.SelectionChangedArgs, sender: Self.ListBox) => void;

		type CustomizeItemCallback = (args: Self.ListBox.CustomizeItemCallbackArgs) => void;

		interface CustomizeItemCallbackArgs {
			index: number;

			dataItem: any;

			listItem: Self.ListItem;

		}

		interface SelectionChangedArgs {
			items: globalThis.Array<any>;

			previousItems: globalThis.Array<any>;

			addedItems: globalThis.Array<any>;

			removedItems: globalThis.Array<any>;

			reason: Self.ListBox.Reason;

		}

		type ComparatorCallback = (left: any, right: any) => boolean;

		type ItemMatcherCallback = (item: Self.ListItem, text: string) => boolean;

		interface EventTypes extends Self.DataSourceComponent.EventTypes {
			SELECTION_CHANGED: string;

			CURSOR_MOVED: string;

			ITEM_UPDATE: string;

			ITEM_CLICKED: string;

			SCROLL_TO_END: string;

		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
			SYSTEM_SEARCH,
		}

		export import DataExchange = Self.ListDataExchange;

		export import Item = Self.ListItem;

		export import ItemVisualStyle = Self.ListItem.VisualStyle;

		enum Reason {
			CURSOR_SET,
			SELECT,
			INVALID_SELECTION,
			SET_MAX_SELECTED_ITEMS_COUNT,
			MULTI_SELECT_DISABLED,
			ITEMS_REMOVED,
			REMOVE_ITEM,
			MOVE_ITEM,
			DATA_RESET,
			NEW_DATA_ROW,
			DATA_BIND,
			DATA_LOADED,
			TOUCH,
			CLICK,
			DOUBLECLICK,
		}

		enum InitialCursorPosition {
			NONE,
			FIRST,
			FIRST_SELECTED,
		}

		enum CursorVisibility {
			FOCUS,
			ALWAYS,
		}

	}

	export class ListBoxPicker extends Self.Picker {
		constructor(options: Self.Picker.Options);

		dataSource: object;

		filter: (dataSource: PackageCore.DataSource, text: string) => PackageCore.DataSource;

		listBox: Self.ListBox;

		debounce: number;

		private _handleSelectionChanged(args: {addedItems: globalThis.Array<any>; removedItems: globalThis.Array<any>}, reason: string): void;

		private _handleListItemClicked(args: {buttons: object}): void;

		private _forwardMessageToList(message: PackageCore.RoutedMessage, result: object): void;

		private _createFilter(options: object): (dataSource: PackageCore.DataSource, text: string) => PackageCore.DataSource;

		static createItemFilter(): (dataSource: PackageCore.DataSource, text: string) => PackageCore.DataSource;

		static formattedContentCreator(): (text: string) => (item: Self.ListItem) => PackageCore.JSX.Element;

	}

	export namespace ListBoxPicker {
		interface Options extends Self.Picker.Options {
			listBox?: Self.ListBox.Options;

			dataSource?: PackageCore.DataSource;

			filter?: Self.ListBoxPicker.FilterCallback;

			filterType?: Self.ListBoxPicker.FilterType;

			highlightItems?: boolean;

			caseSensitive?: boolean;

			debounce?: number;

		}

		type FilterCallback = (dataSource: PackageCore.DataSource, text: string) => PackageCore.DataSource;

		export import Reason = Self.Picker.Reason;

		enum FilterType {
			STARTS_WITH,
			CONTAINS,
		}

	}

	class ListComparatorSelection {
		constructor();

	}

	namespace ListComparatorSelection {
	}

	export namespace ListDataExchange {
		function dragSource(options: object): PackageCore.DataExchange.DragSourceProvider;

		function dragTarget(options: object): PackageCore.DataExchange.DragTargetProvider;

	}

	class ListEqualitySelection {
		constructor();

	}

	namespace ListEqualitySelection {
	}

	export class ListItem extends PackageCore.Component {
		constructor();

		listBox: Self.ListBox;

		parentItem: Self.ListItem;

		childItems: globalThis.Array<Self.ListItem>;

		empty: boolean;

		index: number;

		indexPath: Self.ListBox.IndexPath;

		visibleIndex: number;

		level: number;

		dataEntry: object;

		dataItem: any;

		dataBound: boolean;

		height: (number | null);

		userData: any;

		renderData: (object | null);

		value: any;

		label: string;

		selectable: boolean;

		effectiveSelectable: boolean;

		cursor: boolean;

		contentProvider: (((item: Self.ListItem, renderData: object) => PackageCore.JSX.Element) | null);

		draggable: boolean;

		effectiveDraggable: boolean;

		selected: boolean;

		effectiveVisible: boolean;

		content: (PackageCore.Component | null);

		divider: boolean;

		addItems(items: globalThis.Array<Self.ListItem>, options: {index: number; reason?: string}): void;

		removeItems(index: number, count: number, options: {reason?: string}): void;

		bind(dataEntry: PackageCore.DataStoreEntry, delegate: (Self.ListBox.CustomizeItemCallback | null)): void;

		unbind(): void;

		refresh(): void;

		setSelectable(value: boolean, options: object): void;

		setSelected(value: boolean, options: object): void;

		setCursor(value: boolean): void;

		setDivider(divider: boolean): void;

		setDraggable(value: boolean, options: object): void;

		setHeight(value: (number | null), options: object): void;

		visit(callback: (item: Self.ListItem) => (boolean | null), self: Self.ListItem): void;

		setupVirtualPosition(): void;

		static defaultContent(item: Self.ListItem): PackageCore.JSX.Element;

		static highlightedContent(item: Self.ListItem, options: object): PackageCore.JSX.Element;

		static Event: Self.ListItem.EventTypes;

	}

	export namespace ListItem {
		interface Options extends PackageCore.Component.Options {
			listBox: Self.ListBox;

			index: number;

			level: number;

			height: (number | null);

			dataEntry: PackageCore.DataStoreEntry;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_CHANGED: string;

			SELECTABLE_CHANGED: string;

			EFFECTIVE_SELECTABLE_CHANGED: string;

			DRAGGABLE_CHANGED: string;

			EFFECTIVE_DRAGGABLE_CHANGED: string;

			VISIBLE_CHANGED: string;

			EFFECTIVE_VISIBLE_CHANGED: string;

			HEIGHT_CHANGED: string;

			ITEMS_ADDED: string;

			ITEMS_REMOVED: string;

		}

		enum VisualStyle {
			ITEM,
			GROUP,
			PLAIN,
			BLANK,
		}

	}

	class ListMouseSelectionHandler implements PackageCore.MessageHandler {
		constructor(options: object);

		attach(): void;

		detach(): void;

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

	}

	namespace ListMouseSelectionHandler {
	}

	export enum ListSelectReason {
		KEY_ARROW_UP,
		KEY_ARROW_DOWN,
		KEY_ENTER,
		KEY_SPACE,
		KEY_HOME,
		KEY_END,
		KEY_ALL,
		FOCUS_IN,
	}

	class ListSelectionBar extends PackageCore.Component {
		constructor(options: Self.ListSelectionBar.Options);

		selectedItemsCount: number;

		selectableItemsCount: number;

		maxSelectableItemsCount: number;

		selectedOnly: boolean;

		showSelectedOnlyCheckbox: boolean;

		onSelectAll: (value: boolean) => void;

		onSelectedOnlyChanged: (value: boolean) => void;

	}

	namespace ListSelectionBar {
		interface Options extends PackageCore.Component.Options {
			selectedItemsCount: number;

			selectableItemsCount: number;

			maxSelectableItemsCount: number;

			selectedOnly: boolean;

			showSelectedOnlyCheckbox: boolean;

			onSelectAll: (value: boolean) => void;

			onSelectedOnlyChanged: (value: boolean) => void;

		}

	}

	export class ListView extends PackageCore.Component {
		constructor(options?: Self.ListView.Options);

		dataProvider: (Self.ListView.StaticDataProvider | Self.ListView.PagedDataProvider);

		dataSource: (PackageCore.DataSource | null);

		filteredDataSource: (PackageCore.DataSource | null);

		columns: (Self.DataGrid.ColumnConfiguration | null);

		filters: (globalThis.Array<PackageCore.JSX.Element> | globalThis.Array<Self.FilterFactory.Filter> | null);

		filterValues: Record<string, any>;

		filtersPosition: Self.ListView.FiltersPosition;

		availableFiltersPositions: globalThis.Array<Self.ListView.FiltersPosition>;

		editable: boolean;

		pagination: (Self.Pagination.Options | boolean | null);

		/**
		 * @deprecated
		 */
		paginationSegments: globalThis.Array<{label: string}>;

		totalItemsCount: (number | null);

		selectedPageIndex: (number | null);

		searchPhrase: string;

		refreshButtonVisible: boolean;

		searchBoxVisible: boolean;

		filterHandler: (Self.ListView.FilterHandlerCallback | null);

		dataGridOptions: Self.DataGrid.Options;

		emptyStateMessage: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		errorMessage: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element | null);

		activeLayout: Self.ListView.Layout;

		availableLayouts: globalThis.Array<Self.ListView.Layout>;

		detailRowContent: (Self.GridSyntheticCell.ContentCallback | null);

		detailRowHeight: (number | Self.GridRow.Height);

		masterDetailContent: (Self.ListView.MasterDetailContentCallback | null);

		masterDetailWidth: Self.ListView.MasterDetailWidth;

		masterDetailNoSelectionMessage: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		cursorItem: any;

		itemReorder: boolean;

		itemActionsProvider: (Self.ListView.ItemActionsProvider | null);

		selectedItems: globalThis.Array<any>;

		itemSelection: Self.ListView.ItemSelection;

		viewSelectedItems: boolean;

		ignoreFilters: boolean;

		selectionActions: globalThis.Array<Self.ListView.SelectionAction>;

		listActions: globalThis.Array<Self.ListView.Action>;

		quickSort: (Self.ListView.QuickSortOption | null);

		quickSortOptions: globalThis.Array<Self.ListView.QuickSortOption>;

		sortable: boolean;

		multiColumnSort: boolean;

		sortDirections: globalThis.Array<Self.ListView.SortDirectionConfig>;

		responsiveStrategy: (Self.ListView.ResponsiveStrategy | Self.ListView.ResponsiveStrategyCallback);

		onStateUpdated: (Self.ListView.StateUpdatedCallback | null);

		/**
		 * @deprecated Use dataLoaderVisible
		 */
		loaderVisible: boolean;

		dataLoaderVisible: boolean;

		state: Self.ListView.State;

		dataGrid: (Self.DataGrid | null);

		/**
		 * @deprecated
		 */
		layout: any;

		refresh(args?: {includeFilters?: boolean}): void;

		/**
		 * @deprecated
		 */
		showPage(dataSource: PackageCore.DataSource, pageSize?: number, pageIndex?: number): void;

		/**
		 * @deprecated
		 */
		showData(dataSource: PackageCore.DataSource): void;

		showError(message: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element)): void;

		hideError(): void;

		flushUpdates(): void;

		/**
		 * @deprecated
		 */
		static ofStaticData(options: Self.ListView.LegacyStaticFactoryOptions): Self.ListView;

		/**
		 * @deprecated
		 */
		static ofPagedData(options: Self.ListView.LegacyPagedFactoryOptions): Self.ListView;

		static Event: Self.ListView.EventTypes;

	}

	export namespace ListView {
		interface Options extends PackageCore.Component.Options {
			columns?: Self.DataGrid.ColumnConfiguration;

			dataProvider?: Self.ListView.DataProvider;

			pagedDataProvider?: boolean;

			filters?: (globalThis.Array<PackageCore.JSX.Element> | globalThis.Array<Self.FilterFactory.Filter>);

			filterValues?: Self.ListView.FilterValues;

			filtersPosition?: Self.ListView.FiltersPosition;

			availableFiltersPositions?: globalThis.Array<Self.ListView.FiltersPosition>;

			editable?: boolean;

			pagination?: (Self.Pagination.Options | boolean | null);

			searchPhrase?: string;

			totalItemsCount?: number;

			selectedPageIndex?: number;

			refreshButtonVisible?: boolean;

			searchBoxVisible?: boolean;

			filterHandler?: Self.ListView.FilterHandlerCallback;

			emptyStateMessage?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			errorMessage?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			detailRowContent?: (Self.GridSyntheticCell.ContentCallback | PackageCore.JSX.Element | PackageCore.Component);

			detailRowHeight?: (number | Self.GridRow.Height);

			activeLayout?: Self.ListView.Layout;

			availableLayouts?: globalThis.Array<Self.ListView.Layout>;

			masterDetailContent?: Self.ListView.MasterDetailContentCallback;

			masterDetailWidth?: Self.ListView.MasterDetailWidth;

			masterDetailNoSelectionMessage?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			cursorItem?: any;

			itemReorder?: boolean;

			itemActionsProvider?: Self.ListView.ItemActionsProvider;

			selectedItems?: globalThis.Array<any>;

			itemSelection?: Self.ListView.ItemSelection;

			viewSelectedItems?: boolean;

			ignoreFilters?: boolean;

			selectionActions?: globalThis.Array<Self.ListView.SelectionAction>;

			listActions?: globalThis.Array<Self.ListView.Action>;

			quickSort?: Self.ListView.QuickSortOption;

			quickSortOptions?: globalThis.Array<Self.ListView.QuickSortOption>;

			sortable?: boolean;

			multiColumnSort?: boolean;

			sortDirections?: globalThis.Array<Self.ListView.SortDirectionConfig>;

			dataGridOptions?: Self.DataGrid.Options;

			dataLoaderVisible?: boolean;

			responsiveStrategy?: (Self.ListView.ResponsiveStrategy | Self.ListView.ResponsiveStrategyCallback);

			onStateUpdated?: Self.ListView.StateUpdatedCallback;

		}

		interface State {
			quickSort: (Self.ListView.QuickSortOption | null);

			filtersIgnored: boolean;

			filters: globalThis.Array<Self.ListView.FilterState>;

			activeFilters: globalThis.Array<Self.ListView.FilterState>;

			filterValues: Self.ListView.FilterValues;

			searchPhrase: string;

			viewSelectedItems: globalThis.Array<any>;

			sorting: globalThis.Array<Self.ListView.SortDirectionState>;

			pagination: Self.ListView.PaginationState;

		}

		type FilterId = (string | number);

		interface FilterState {
			id: Self.ListView.FilterId;

			value: any;

			filterPredicate: Self.ListView.FilterPredicate;

		}

		type FilterPredicate = (item: any, value: any) => boolean;

		type ComposedFilterPredicate = (item: any) => boolean;

		interface PaginationState {
			rowsPerPage: number;

			currentPage: object;

			currentIndex: number;

		}

		type DataProvider = (Self.ListView.StaticDataProvider | Self.ListView.PagedDataProvider);

		type StaticDataProvider = () => PackageCore.DataSource;

		type PagedDataProvider = (state: Self.ListView.State) => globalThis.Promise<Self.ListView.PagedDataProviderResult>;

		interface PagedDataProviderResult {
			dataSource: PackageCore.DataSource;

			totalItemsCount?: number;

		}

		type StateUpdatedCallback = (args: Self.ListView.StateUpdatedCallbackArgs) => void;

		interface StateUpdatedCallbackArgs {
			state: Self.ListView.State;

			previousState: Self.ListView.State;

		}

		type FilterHandlerCallback = (args: Self.ListView.FilterHandlerCallbackArgs) => PackageCore.DataSource;

		interface FilterHandlerCallbackArgs {
			dataSource: PackageCore.DataSource;

			predicate: Self.ListView.ComposedFilterPredicate;

			searchPhrasePredicate: Self.ListView.ComposedFilterPredicate;

			filtersPredicate: Self.ListView.ComposedFilterPredicate;

			state: any;

		}

		type FilterValues = Record<Self.ListView.FilterId, any>;

		type MasterDetailContentCallback = (dataItem: any) => (null | PackageCore.Component | PackageCore.JSX.Element);

		type ItemActionsProvider = (dataItem: any) => globalThis.Array<Self.ListView.Action>;

		type Action = (Self.ListView.ButtonAction | Self.ListView.LinkAction);

		interface ButtonAction {
			icon?: Self.Image.Source;

			iconOnly?: boolean;

			label?: (string | PackageCore.Translation);

			action?: Self.Button.ActionCallback;

			type?: Self.Button.Type;

			items?: globalThis.Array<Self.MenuItem.ItemDefinition>;

			enabled?: boolean;

		}

		interface LinkAction {
			url?: (string | PackageCore.Url);

			route?: (string | PackageCore.Route | Self.Link.Route);

			label: (string | PackageCore.Translation);

			enabled?: boolean;

		}

		interface SelectionAction {
			action?: Self.ListView.SelectionActionCallback;

			icon?: Self.Image.Source;

			iconPosition?: Self.Button.IconPosition;

			label?: (null | string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			type?: Self.Button.Type;

		}

		type SelectionActionCallback = (selectedItems: globalThis.Array<any>) => void;

		interface QuickSortOption {
			id: any;

			icon?: Self.Image.Source;

			label: (string | PackageCore.Translation);

		}

		interface SortDirectionConfig {
			columnName: string;

			direction: Self.ListView.SortDirection;

		}

		interface SortDirectionState extends Self.ListView.SortDirectionConfig {
			column?: Self.DataGrid.ColumnDefinition;

		}

		type ResponsiveStrategyCallback = (args: Self.ListView.ResponsiveStrategyCallbackArgs) => Self.ListView.ResponsiveStrategyCallbackResult;

		interface ResponsiveStrategyCallbackArgs {
			width: number;

			searchBoxVisible: boolean;

			filtersPostion: Self.ListView.FiltersPosition;

			filterCount: number;

			listActionCount: number;

		}

		interface ResponsiveStrategyCallbackResult {
			collapseSearchBox?: boolean;

			collapseFilters?: boolean;

			maxVisibleListActions?: number;

			listActionsBelowFilters?: boolean;

		}

		interface MasterDetailWidthOption {
			master: Self.SplitPanelItem.SizeOptions;

			detail: Self.SplitPanelItem.SizeOptions;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			STATE_UPDATED: string;

			SELECTION_CHANGED: string;

			REFRESH_REQUESTED: string;

			ITEM_REORDERED: string;

			ITEM_EDITED: string;

		}

		export import ColumnFactory = Self.ListViewColumnFactory;

		export import FiltersPosition = Self.ListViewConstant.FiltersPosition;

		export import Filter = Self.ListViewFilter;

		export import TextBoxFilterMatchingOperator = Self.ListViewConstant.TextBoxFilterMatchingOperator;

		namespace Pagination {
			function basic(rowsCount?: number, rowsPerPage?: number): Self.Pagination.Options;

			function customizablePageSize(rowsCount?: number, rowsPerPage?: number): Self.Pagination.Options;

			function segmented(segments: globalThis.Array<object>): Self.Pagination.Options;

		}

		export import Layout = Self.ListViewConstant.Layout;

		export import MasterDetailWidth = Self.ListViewConstant.MasterDetailWidth;

		/**
		 * @deprecated Use ListView.MasterDetailWidth instead
		 */
		export import TableMasterDetailWidth = Self.ListViewConstant.MasterDetailWidth;

		export import SortDirection = Self.GridConstants.SortDirection;

		export import ItemSelection = Self.ListViewConstant.ItemSelection;

		export import Visibility = Self.ListViewConstant.Visibility;

		export import VisibilityBreakpoint = Self.GridColumn.VisibilityBreakpoint;

		export import ResponsiveStrategy = Self.ListViewConstant.ResponsiveStrategy;

		interface LegacyOptions extends PackageCore.Component.Options {
			defaultLayout?: Self.ListView.Layout;

			availableLayouts?: Record<Self.ListView.Layout, boolean>;

			refreshButtonVisible?: boolean;

			searchBoxVisible?: boolean;

			listActions?: globalThis.Array<any>;

			itemActionsProvider?: (dataItem: any) => globalThis.Array<any>;

			selectionActions?: globalThis.Array<any>;

			itemSelection?: Self.ListView.ItemSelection;

			filtersPosition?: Self.ListView.FiltersPosition;

			availableFiltersPositions?: globalThis.Array<Self.ListView.FiltersPosition>;

			filters?: globalThis.Array<Self.FilterFactory.Filter>;

			quickSortOptions?: globalThis.Array<any>;

			responsiveStrategy?: Self.ListView.ResponsiveStrategy;

			layout?: object;

			totalItemsCount?: number;

			emptyStateMessage?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			itemReorder?: boolean;

			pagination?: Self.Pagination.Options;

		}

		interface LegacyStaticFactoryOptions extends Self.ListView.LegacyOptions {
			parentContext?: PackageCore.Context;

			dataProvider: Self.ListView.StaticDataProvider;

			filterHandler?: Self.ListView.FilterHandlerCallback;

		}

		interface LegacyPagedFactoryOptions extends Self.ListView.LegacyOptions {
			parentContext?: PackageCore.Context;

			dataProvider: Self.ListView.PagedDataProvider;

		}

		interface BaseFilterProps {
			id: Self.ListView.FilterId;

			label: string;

			binding?: string;

			filterPredicate?: Self.ListView.FilterPredicate;

		}

		type CreateColumnOptions = (Omit<Self.ActionColumn.Options, "type"> | Omit<Self.CheckBoxColumn.Options, "type"> | Omit<Self.DatePickerColumn.Options, "type"> | Omit<Self.DropdownColumn.Options, "type"> | Omit<Self.GrabColumn.Options, "type"> | Omit<Self.LinkColumn.Options, "type"> | Omit<Self.MultiselectDropdownColumn.Options, "type"> | Omit<Self.SelectionColumn.Options, "type"> | Omit<Self.TemplatedColumn.Options, "type"> | Omit<Self.TextAreaColumn.Options, "type"> | Omit<Self.TextBoxColumn.Options, "type"> | Omit<Self.TimePickerColumn.Options, "type"> | Omit<Self.TreeColumn.Options, "type">);

	}

	export namespace ListViewColumnFactory {
		function createTextColumn(columnOptions: Omit<Self.TextBoxColumn.Options, "type">, widgetOptions?: Self.TextBox.Options): Self.TextBoxColumn.Options;

		function createNumberColumn(columnOptions: Omit<Self.TextBoxColumn.Options, "type">, widgetOptions?: Self.TextBox.Options): Self.TextBoxColumn.Options;

		function createTimeColumn(columnOptions: Omit<Self.TimePickerColumn.Options, "type">, widgetOptions?: Self.TimePicker.Options): Self.TimePickerColumn.Options;

		function createDateColumn(columnOptions: Omit<Self.DatePickerColumn.Options, "type">, widgetOptions?: Self.DatePicker.Options): Self.DatePickerColumn.Options;

		function createDateTimeColumn(columnOptions: Omit<Self.DatePickerColumn.Options, "type">, widgetOptions?: Self.DatePicker.Options): Self.DatePickerColumn.Options;

		function createCheckColumn(columnOptions: Omit<Self.CheckBoxColumn.Options, "type">, widgetOptions?: Self.CheckBox.Options): Self.CheckBoxColumn.Options;

		function createLinkColumn(columnOptions: Omit<Self.LinkColumn.Options, "type">, widgetOptions?: Self.Link.Options): Self.LinkColumn.Options;

		/**
		 * @deprecated
		 */
		function createImageColumn(columnOptions: Omit<Self.TemplatedColumn.Options, "type">, widgetOptions?: Self.Image.Options): Self.TemplatedColumn.Options;

		function createTextAreaColumn(columnOptions: Omit<Self.TextAreaColumn.Options, "type">, widgetOptions?: Self.TextArea.Options): Self.TextAreaColumn.Options;

		/**
		 * @deprecated
		 */
		function createEditViewColumn(columnOptions: Omit<Self.TemplatedColumn.Options, "type">, widgetOptions?: object): Self.TemplatedColumn.Options;

		function create(columnType: Self.ListViewColumnFactory.ColumnType, columnOptions: Self.ListView.CreateColumnOptions, widgetOptions?: object): Self.DataGrid.ColumnDefinition;

		enum ColumnType {
			CHECK,
			DATE,
			TIME,
			DATE_TIME,
			LINK,
			NUMBER,
			TEXT_BOX,
			TEXT_AREA,
			EDIT_VIEW,
			IMAGE,
			ACTION,
			TEMPLATED,
		}

	}

	namespace ListViewConstant {
		enum ItemSelection {
			NONE,
			SINGLE,
			MULTIPLE,
		}

		enum Layout {
			TABLE,
			TABLE_DETAIL,
		}

		enum FiltersPosition {
			TOP,
			SIDE,
			NONE,
		}

		enum Visibility {
			ABOVE,
			BELOW,
			FOR,
		}

		enum ResponsiveStrategy {
			ONE_LINE,
			TWO_LINES,
		}

		enum TextBoxFilterMatchingOperator {
			STARTS_WITH,
			ENDS_WITH,
			CONTAINS,
		}

		enum MasterDetailWidth {
			EQUAL,
			SMALL_DETAIL,
			LARGE_DETAIL,
			CONTENT,
		}

	}

	export namespace ListViewFilter {
		function Custom(props: {id: Self.ListView.FilterId; filterPredicate: Self.ListView.FilterPredicate; children?: PackageCore.JSX.Element}): PackageCore.JSX.Element;

		function CheckBox(props: Self.ListView.BaseFilterProps): PackageCore.JSX.Element;

		function TextBox(props: Self.ListView.BaseFilterProps & {matchingOperator?: Self.ListView.TextBoxFilterMatchingOperator}): PackageCore.JSX.Element;

		function Toggle(props: Self.ListView.BaseFilterProps): PackageCore.JSX.Element;

		function Dropdown(props: Self.ListView.BaseFilterProps & {dataSource: PackageCore.DataSource; displayMember?: Self.DataSourceComponent.DisplayMember; valueMember?: Self.DataSourceComponent.ValueMember; search?: boolean}): PackageCore.JSX.Element;

		function MultiselectDropdown(props: Self.ListView.BaseFilterProps & {dataSource: PackageCore.DataSource; displayMember?: Self.DataSourceComponent.DisplayMember; valueMember?: Self.DataSourceComponent.ValueMember}): PackageCore.JSX.Element;

		function Date(props: Self.ListView.BaseFilterProps): PackageCore.JSX.Element;

		function DateRange(props: Self.ListView.BaseFilterProps): PackageCore.JSX.Element;

		function Time(props: Self.ListView.BaseFilterProps): PackageCore.JSX.Element;

		function TimeRange(props: Self.ListView.BaseFilterProps): PackageCore.JSX.Element;

	}

	export class Loader extends PackageCore.Component {
		constructor(options?: Self.Loader.Options);

		label: (string | number | PackageCore.Translation | PackageCore.Component);

		startLabel: (string | number | PackageCore.Translation | PackageCore.Component);

		endLabel: (string | number | PackageCore.Translation | PackageCore.Component);

		icon: (Self.Image.Source | Self.Loader.Icon | null);

		verticalAlignment: Self.Loader.VerticalAlignment;

		horizontalAlignment: Self.Loader.HorizontalAlignment;

		labelAlignment: Self.Loader.LabelAlignment;

		size: Self.Loader.Size;

		showCurtain: boolean;

		indeterminate: boolean;

		value: number;

		max: number;

		embedded: boolean;

		parentBorderSize: number;

		coverParent: boolean;

		setIcon(icon: Self.Image.Source): void;

		setLabel(label: (string | PackageCore.Translation | PackageCore.Component)): void;

		setStartLabel(label: (string | PackageCore.Translation | PackageCore.Component)): void;

		setEndLabel(label: (string | PackageCore.Translation | PackageCore.Component)): void;

		setVerticalAlignment(alignment: Self.Loader.VerticalAlignment): void;

		setHorizontalAlignment(alignment: Self.Loader.HorizontalAlignment): void;

		setLabelAlignment(labelAlignment: Self.Loader.LabelAlignment): void;

		setValue(value: number): void;

		setMax(max: number): void;

		setEmbedded(value: boolean): void;

		setSize(size: Self.Loader.Size): void;

		setShowCurtain(showCurtain: boolean): void;

		private _getProgress(): number;

	}

	export namespace Loader {
		interface Options extends PackageCore.Component.Options {
			embedded?: boolean;

			label?: (string | number | PackageCore.Translation | PackageCore.Component);

			startLabel?: (string | number | PackageCore.Translation | PackageCore.Component);

			endLabel?: (string | number | PackageCore.Translation | PackageCore.Component);

			horizontalAlignment?: Self.Loader.HorizontalAlignment;

			icon?: (Self.Image.Source | Self.Loader.Icon);

			labelAlignment?: Self.Loader.LabelAlignment;

			max?: number;

			showCurtain?: boolean;

			size?: Self.Loader.Size;

			target?: (HTMLElement | PackageCore.Component);

			value?: number;

			verticalAlignment?: Self.Loader.VerticalAlignment;

			coverParent?: boolean;

			parentBorderSize?: number;

			parentHasStaticPosition?: boolean;

		}

		enum VisualStyle {
			DARK,
			LIGHT,
		}

		enum Icon {
			CIRCULAR,
			HORIZONTAL,
		}

		enum VerticalAlignment {
			TOP,
			MIDDLE,
			BOTTOM,
		}

		enum HorizontalAlignment {
			START,
			END,
			CENTER,
			STRETCH,
		}

		enum LabelAlignment {
			START,
			END,
			TOP,
			BOTTOM,
		}

		enum Size {
			SMALL,
			MEDIUM,
			LARGE,
			EXTRA_LARGE,
			EXTRA_EXTRA_LARGE,
		}

		enum DataAttribute {
			SIZE,
			HORIZONTAL_ALIGNMENT_,
			VERTICAL_ALIGNMENT,
			LABEL_ALIGNMENT,
			ICON,
			COVER_PARENT,
			EMBEDDED,
			CURTAIN,
			LABEL_TYPE,
			TARGET,
			ICON_OUTLINE,
			ICON_RUNNER,
		}

	}

	export class MaskedCharacter {
		constructor(character: (string | null), rule: (Self.MaskedCharacter.Rule | null));

		characterOrPlaceholder: string;

		characterOrFill: (string | null);

		equals(maskedCharacter: Self.MaskedCharacter): boolean;

		isEmpty(): boolean;

		isTerminal(): boolean;

		matches(character: string): boolean;

		clear(): Self.MaskedCharacter;

		fill(character: string): Self.MaskedCharacter;

		static terminal(character: string): Self.MaskedCharacter;

		static filled(character: string, rule: Self.MaskedCharacter.Rule): Self.MaskedCharacter;

		static empty(rule: Self.MaskedCharacter.Rule): Self.MaskedCharacter;

	}

	export namespace MaskedCharacter {
		interface Rule {
			match: (character: string) => boolean;

			fill?: string;

			placeholder?: string;

		}

	}

	export class MaskedText {
		constructor(value: globalThis.Array<Self.MaskedCharacter>);

		length: number;

		empty: boolean;

		text: string;

		rawText: globalThis.Array<string>;

		maskedText: string;

		equals(maskedText: Self.MaskedText): boolean;

		at(index: number): Self.MaskedCharacter;

		setRawText(text: globalThis.Array<string>): Self.MaskedText;

		insertText(text: string, start: number, end: number): Self.MaskedText;

		clearText(start: number, end: number): Self.MaskedText;

		static create(mask: string, rules: Record<string, Self.MaskedCharacter.Rule>): Self.MaskedText;

	}

	export namespace MaskedText {
	}

	export class MaskedTextBox extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.MaskedTextBox.Options);

		data: Self.MaskedText;

		text: string;

		rawText: globalThis.Array<string>;

		inputText: string;

		acceptedData: Self.MaskedText;

		acceptedText: string;

		acceptedRawText: string;

		empty: boolean;

		mandatory: boolean;

		selection: Self.MaskedTextBox.Selection;

		caretPosition: number;

		textAlignment: Self.MaskedTextBox.TextAlignment;

		clearButton: boolean;

		inputSize: number;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		size: Self.MaskedTextBox.Size;

		onTextChanged: (Self.MaskedTextBox.TextChangedCallback | null);

		onTextAccepted: (Self.MaskedTextBox.TextAcceptedCallback | null);

		setText(text: string, options?: {reason?: string; accept?: boolean}): void;

		setRawText(rawText: globalThis.Array<string>, options?: {reason?: string; accept?: boolean}): void;

		setSelection(options: {start: number; end: number; direction?: Self.MaskedTextBox.SelectionDirection; reason?: string}): boolean;

		setCaretPosition(position: number): void;

		setInputSize(size: number): void;

		setTextAlignment(alignment: Self.MaskedTextBox.TextAlignment): void;

		setClearButton(value: boolean): void;

		selectAll(): boolean;

		acceptChanges(options: {reason?: string}): void;

		static Event: Self.MaskedTextBox.EventTypes;

	}

	export namespace MaskedTextBox {
		interface Options extends PackageCore.Component.Options {
			acceptInvalidValue?: boolean;

			clearButton?: boolean;

			inputSize?: (number | null);

			mask?: string;

			rules: Record<string, Self.MaskedCharacter.Rule>;

			text: (string | number);

			textAlignment?: Self.MaskedTextBox.TextAlignment;

			mandatory?: boolean;

			size?: Self.MaskedTextBox.Size;

			textValidator?: Self.MaskedTextBox.TextValidatorCallback;

			onTextChanged?: Self.MaskedTextBox.TextChangedCallback;

			onTextAccepted?: Self.MaskedTextBox.TextAcceptedCallback;

		}

		type TextChangedCallback = (args: Self.MaskedTextBox.TextChangedArgs, sender: Self.MaskedTextBox) => void;

		interface TextChangedArgs {
			text: string;

			previousText: string;

			rawText: string;

			previousRawText: string;

			reason: Self.MaskedTextBox.TextChangeReason;

		}

		type TextAcceptedCallback = (args: Self.MaskedTextBox.TextAcceptedArgs, sender: Self.MaskedTextBox) => void;

		interface TextAcceptedArgs {
			text: string;

			previousText: string;

			rawText: string;

			previousRawText: string;

			reason: Self.MaskedTextBox.TextAcceptedReason;

		}

		type TextValidatorCallback = (args: Self.MaskedTextBox.TextValidatorCallbackArgs) => boolean;

		interface TextValidatorCallbackArgs {
			text: string;

			rawText: globalThis.Array<string>;

		}

		interface Selection {
			start: number;

			end: number;

			direction?: Self.MaskedTextBox.SelectionDirection;

			text?: string;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TEXT_CHANGED: string;

			TEXT_ACCEPTED: string;

			SELECTION_CHANGED: string;

			CARET_POSITION_CHANGED: string;

		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
			REDWOOD_FIELD,
		}

		enum TextAlignment {
			LEFT,
			RIGHT,
			CENTER,
		}

		enum TextChangeReason {
			INPUT,
			MAX_LENGTH,
		}

		enum TextAcceptedReason {
			FOCUS_OUT,
			ENTER,
			CALL,
		}

		enum SelectionChangeReason {
			SELECT_ALL,
			TEXT_CHANGED,
			REFRESH,
		}

		enum Reason {
			INSERT,
			CLEAR,
		}

		export import MaskedCharacter = Self.MaskedCharacter;

		export import MaskedText = Self.MaskedText;

		export import Size = Self.InputSize;

		export import SelectionDirection = Self.TextSelection.Direction;

	}

	class Matcher {
		addElements(elements: globalThis.Map<any, any>): void;

		removeElement(elementId: any): void;

	}

	namespace Matcher {
	}

	export class Menu extends PackageCore.Component {
		constructor(options?: Self.Menu.Options);

		role: Self.Menu.Role;

		items: globalThis.Array<Self.MenuItem>;

		children: PackageCore.VDom.Children;

		collapseOnAction: boolean;

		orientation: Self.Menu.Orientation;

		size: Self.Menu.Size;

		type: Self.Menu.Type;

		setOrientation(orientation: Self.Menu.Orientation): void;

		setSize(size: Self.Menu.Size): void;

		select(value: string): boolean;

		highlight(value: string): boolean;

		private handleAction(args: object): void;

		private selectItem(item: Self.MenuItem, reason?: string): boolean;

		private selectNextItem(item?: Self.MenuItem, reason?: string): boolean;

		private selectPreviousItem(item?: Self.MenuItem, reason?: string): boolean;

		private selectFirstItem(reason?: string): boolean;

		private selectLastItem(reason?: string): boolean;

		private hasSubmenu(item: Self.MenuItem): boolean;

		private isSubmenuOpened(item?: Self.MenuItem): (boolean | null);

		private getOpenedSubmenu(item?: Self.MenuItem): (Self.Menu | null);

		private openSubmenu(item: PackageCore.Component, reason?: string): (Self.Menu | null);

		private closeSubmenu(reason?: string): boolean;

		private toggleSubmenu(item: PackageCore.Component, reason?: string): boolean;

		private findItemByComponent(component: PackageCore.Component, transitive?: boolean): (PackageCore.Component | null);

		static vertical(items: globalThis.Array<Self.MenuItem>): void;

		static horizontal(items: globalThis.Array<Self.MenuItem>): void;

		private static _createMenuWindow(menu: Self.Menu, windowOptions?: Self.Window.Options): Self.Window;

		static Event: Self.Menu.EventTypes;

		static Item(props?: Self.MenuItem.ItemDefinition): PackageCore.JSX.Element;

		static Group(options?: Self.MenuGroup.Options): PackageCore.JSX.Element;

	}

	export namespace Menu {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items?: globalThis.Array<Self.MenuItem.ItemDefinition>;

			circularSelection?: boolean;

			collapseOnAction?: boolean;

			orientation?: Self.Menu.Orientation;

			scrollControl?: Self.Menu.ScrollControl;

			role?: Self.Menu.Role;

			size?: Self.Menu.Size;

			stackIcon?: boolean;

			type?: Self.Menu.Type;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ACTION: string;

			ITEM_SELECTED: string;

			SUBMENU_OPENED: string;

			SUBMENU_CLOSED: string;

		}

		export import Orientation = Self.MenuOptions.Orientation;

		export import Role = Self.MenuOptions.Role;

		export import Reason = Self.MenuOptions.Reason;

		export import Size = Self.MenuOptions.Size;

		export import Type = Self.MenuOptions.Type;

		export import VisualStyle = Self.MenuOptions.VisualStyle;

		enum ItemType {
			MENU_ITEM,
			ITEM,
			GROUP,
		}

		export import ScrollControl = Self.ScrollPanel.ScrollControl;

	}

	export class MenuBar extends PackageCore.Component {
		constructor(options?: Self.MenuBar.Options);

	}

	export namespace MenuBar {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items: globalThis.Array<Self.MenuItem>;

			menu: Self.Menu.Options;

			justification?: Self.MenuBar.Justification;

		}

		enum Justification {
			START,
			END,
		}

	}

	export class MenuButton extends Self.Button {
		constructor(options?: Self.MenuButton.Options);

		menuOpened: boolean;

		menu: (globalThis.Array<Self.MenuItem.ItemDefinition> | Self.Menu.Options);

		openOnHover: boolean;

		menuTarget: Self.Window.Target;

		setMenu(menu: (globalThis.Array<Self.MenuItem.ItemDefinition> | Self.Menu)): void;

		openMenu(args?: object): void;

		closeMenu(args?: {reason: string}): void;

		toggleMenu(args?: object): void;

		static dropDown(options: Self.MenuButton.Options): Self.MenuButton;

		static DropDown(props: Self.MenuButton.Options): PackageCore.JSX.Element;

		static Event: Self.MenuButton.EventTypes;

	}

	export namespace MenuButton {
		interface Options extends Self.Button.Options {
			children?: PackageCore.VDom.Children;

			menu: (globalThis.Array<Self.MenuItem.ItemDefinition> | Self.Menu.Options);

			openOnHover?: boolean;

			menuTarget?: Self.Window.Target;

		}

		interface EventTypes extends Self.Button.EventTypes {
			MENU_OPENED: string;

			MENU_CLOSED: string;

		}

		export import Size = Self.Button.Size;

		export import IconPosition = Self.Button.IconPosition;

		export import Type = Self.Button.Type;

		export import Hierarchy = Self.Button.Hierarchy;

		export import VisualStyle = Self.Button.VisualStyle;

	}

	export class MenuGroup extends PackageCore.Component {
		constructor(options?: Self.MenuGroup.Options);

		children: PackageCore.VDom.Children;

		label: (string | PackageCore.Translation);

		private hasLabel: boolean;

		icon: (Self.Image.Source | null);

		private hasIcon: boolean;

		focusableItems: globalThis.Array<PackageCore.Component>;

		setIcon(icon: (Self.Image.Source | null)): void;

		setLabel(label: string): void;

	}

	export namespace MenuGroup {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items?: globalThis.Array<PackageCore.Component>;

			label?: (string | PackageCore.Translation);

			icon?: Self.Image.Source;

		}

	}

	export class MenuItem extends PackageCore.Component {
		constructor(options?: Self.MenuItem.Options);

		selected: boolean;

		highlighted: boolean;

		opened: boolean;

		submenu: Self.Menu;

		value: (any | Self.MenuItem);

		private _getActionHandler(): void;

		static CustomItem(definition: Self.MenuItem.CustomItemDefinition): Self.MenuItem;

		static ActionItem(definition: Self.MenuItem.ActionItemDefinition): Self.MenuItem;

		static LinkItem(definition: Self.MenuItem.LinkItemDefinition): Self.MenuItem;

	}

	export namespace MenuItem {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content: PackageCore.Component;

			highlighted?: boolean;

			value?: any;

			submenuItems?: globalThis.Array<object>;

		}

		interface BaseItemDefinition {
			children?: PackageCore.VDom.Children;

			items?: globalThis.Array<Self.MenuItem.ItemDefinition>;

			highlighted?: boolean;

			visible?: boolean;

			enabled?: boolean;

			classList?: globalThis.Array<string>;

		}

		interface SubmenuItemDefinition extends Self.MenuItem.BaseItemDefinition {
			icon?: Self.Image.Source;

			label?: (string | PackageCore.Translation);

		}

		interface CustomItemDefinition extends Self.MenuItem.BaseItemDefinition {
			content?: (PackageCore.Component | PackageCore.VDom.Element);

			action: Self.MenuItemButton.ActionCallback;

		}

		interface ActionItemDefinition extends Self.MenuItem.BaseItemDefinition {
			icon?: Self.Image.Source;

			startIcon?: Self.Image.Source;

			endIcon?: Self.Image.Source;

			label?: (string | PackageCore.Translation);

			action: Self.MenuItemButton.ActionCallback;

			shortcut?: globalThis.Array<globalThis.Array<string>>;

		}

		interface LinkItemDefinition extends Self.MenuItem.BaseItemDefinition {
			icon?: Self.Image.Source;

			startIcon?: Self.Image.Source;

			endIcon?: Self.Image.Source;

			label?: (string | PackageCore.Translation);

			url?: string;

			route?: (string | PackageCore.Route | Self.Link.Route);

			target?: Self.Link.Target;

			shortcut?: globalThis.Array<globalThis.Array<string>>;

		}

		type ItemDefinition = (Self.MenuItem.SubmenuItemDefinition | Self.MenuItem.ActionItemDefinition | Self.MenuItem.LinkItemDefinition | Self.MenuItem.CustomItemDefinition);

	}

	export class MenuItemButton extends PackageCore.Component {
		constructor(options?: Self.MenuItemButton.Options);

		protected _doAction(options: object): void;

		click(): void;

	}

	export namespace MenuItemButton {
		interface Options extends PackageCore.Component.Options {
			content: PackageCore.Component;

			action?: Self.MenuItemButton.ActionCallback;

		}

		type ActionCallback = (args: {reason: string}) => (boolean | void);

		enum Reason {
			KEY_UP,
			CLICK,
			TAP,
		}

	}

	export class MenuItemContent extends PackageCore.Component {
		constructor(options?: Self.MenuItemContent.Options);

		endIcon: (Self.Image.Source | null);

		startIcon: (Self.Image.Source | null);

		label: (string | PackageCore.Translation);

		hasLabel: boolean;

		icon: (Self.Image.Source | null);

		hasIcon: boolean;

		shortcut: string;

		hasShortcut: boolean;

		setLabel(label: string): void;

		setIcon(icon: object): void;

		setShortcut(shortcut: string): void;

		static getRefreshedStyles(theme: PackageCore.RefreshedTheme): void;

	}

	export namespace MenuItemContent {
		interface Options extends PackageCore.Component.Options {
			label?: (string | PackageCore.Translation);

			icon?: Self.Image.Source;

			startIcon?: Self.Image.Source;

			endIcon?: Self.Image.Source;

			shortcut?: string;

		}

	}

	namespace MenuOptions {
		enum Orientation {
			VERTICAL,
			HORIZONTAL,
		}

		enum NavigationMode {
			CIRCULAR,
			START_END,
		}

		enum Reason {
			SUBMENU_ITEM_SELECTED,
			KEY_PRESS,
			MOUSE_ENTER,
			MOUSE_LEAVE,
			MOUSE_CLICK,
			TOUCH_TAP,
			CALL,
			CLEAR,
			FOCUS,
			ACTION,
		}

		enum Role {
			MENU,
			MENUBAR,
		}

		enum Size {
			DEFAULT,
			LARGE,
		}

		enum VisualStyle {
			DEFAULT,
			THEMED,
		}

		enum Type {
			DEFAULT,
			CONTEXT_MENU,
		}

	}

	export class MeterBar extends PackageCore.Component {
		constructor(options?: (Self.MeterBar.Options));

		type: Self.MeterBar.Type;

		value: number;

		min: number;

		max: number;

		step: number;

		readOnly: boolean;

		plotAreaColor: Self.MeterBar.ColorConfig;

		plotAreaSize: Self.MeterBar.Size;

		indicatorBarColor: Self.MeterBar.ColorConfig;

		indicatorBarSize: Self.MeterBar.Size;

		referenceLines: globalThis.Array<Self.MeterBar.ReferenceLine>;

		referenceLinesSize: Self.MeterBar.Size;

		onValueChanged: (Self.MeterBar.ValueChangedCallback | null);

		onValueAccepted: (Self.MeterBar.ValueAcceptedCallback | null);

		setValue(value: number, options: object): void;

		acceptChanges(options: object): void;

		static basicDynamicColor(errorToWarning: number, warningToSuccess: number): Self.MeterBar.ValueColorCallback;

		static basicColorSegments(errorToWarning: number, warningToSuccess: number): globalThis.Array<Self.MeterBar.SegmentColor>;

	}

	export namespace MeterBar {
		interface Options extends PackageCore.Component.Options {
			type?: Self.MeterBar.Type;

			value?: number;

			min?: number;

			max?: number;

			readOnly?: boolean;

			step?: number;

			plotAreaColor?: Self.MeterBar.ColorConfig;

			plotAreaSize?: Self.MeterBar.Size;

			indicatorBarColor?: Self.MeterBar.ColorConfig;

			indicatorBarSize?: Self.MeterBar.Size;

			referenceLines?: globalThis.Array<Self.MeterBar.ReferenceLine>;

			referenceLinesSize?: Self.MeterBar.Size;

			onValueChanged?: Self.MeterBar.ValueChangedCallback;

			onValueAccepted?: Self.MeterBar.ValueAcceptedCallback;

		}

		type ColorConfig = (Self.MeterBar.Color | Self.MeterBar.ValueColorCallback | globalThis.Array<Self.MeterBar.SegmentColor>);

		interface SegmentColor {
			min?: number;

			max?: number;

			color: Self.MeterBar.Color;

		}

		interface ReferenceLine {
			value: number;

			color: Self.MeterBar.Color;

		}

		type ValueColorCallback = (value: number) => Self.MeterBar.Color;

		type ValueChangedCallback = (args: Self.MeterBar.ValueChangedCallbackArgs) => void;

		interface ValueChangedCallbackArgs {
			value: number;

			previousValue: number;

			reason: Self.MeterBar.Reason;

		}

		type ValueAcceptedCallback = (args: Self.MeterBar.ValueAcceptedCallbackArgs) => void;

		interface ValueAcceptedCallbackArgs {
			acceptedValue: number;

			previousAcceptedValue: number;

			reason: Self.MeterBar.Reason;

		}

		enum Type {
			HORIZONTAL,
			VERTICAL,
		}

		enum Size {
			LARGE,
			MEDIUM,
			SMALL,
		}

		enum Color {
			NEUTRAL,
			INFO,
			SUCCESS,
			WARNING,
			ERROR,
		}

		enum Reason {
			VALUE_CHANGED,
			VALUE_ACCEPTED,
		}

	}

	export class MeterCircle extends PackageCore.Component {
		constructor(options?: (Self.MeterCircle.Options));

		type: Self.MeterCircle.Type;

		value: number;

		min: number;

		max: number;

		step: number;

		readOnly: boolean;

		plotAreaColor: Self.MeterCircle.ColorConfig;

		plotAreaSize: Self.MeterCircle.Size;

		indicatorBarColor: Self.MeterCircle.ColorConfig;

		indicatorBarSize: Self.MeterCircle.Size;

		referenceLines: globalThis.Array<Self.MeterCircle.ReferenceLine>;

		referenceLinesSize: Self.MeterCircle.Size;

		onValueChanged: (Self.MeterCircle.ValueChangedCallback | null);

		onValueAccepted: (Self.MeterCircle.ValueAcceptedCallback | null);

		setValue(value: number, options: object): void;

		acceptChanges(options: object): void;

		static basicDynamicColor(errorToWarning: number, warningToSuccess: number): Self.MeterCircle.ValueColorCallback;

		static basicColorSegments(errorToWarning: number, warningToSuccess: number): globalThis.Array<Self.MeterCircle.SegmentColor>;

	}

	export namespace MeterCircle {
		interface Options extends PackageCore.Component.Options {
			type?: Self.MeterCircle.Type;

			value?: number;

			min?: number;

			max?: number;

			readOnly?: boolean;

			step?: number;

			plotAreaColor?: Self.MeterCircle.ColorConfig;

			plotAreaSize?: Self.MeterCircle.Size;

			indicatorBarColor?: Self.MeterCircle.ColorConfig;

			indicatorBarSize?: Self.MeterCircle.Size;

			referenceLines?: globalThis.Array<Self.MeterCircle.ReferenceLine>;

			referenceLinesSize?: Self.MeterCircle.Size;

			onValueChanged?: Self.MeterCircle.ValueChangedCallback;

			onValueAccepted?: Self.MeterCircle.ValueAcceptedCallback;

		}

		type ColorConfig = (Self.MeterCircle.Color | Self.MeterCircle.ValueColorCallback | globalThis.Array<Self.MeterCircle.SegmentColor>);

		interface SegmentColor {
			min?: number;

			max?: number;

			color: Self.MeterCircle.Color;

		}

		interface ReferenceLine {
			value: number;

			color: Self.MeterCircle.Color;

		}

		type ValueColorCallback = (value: number) => Self.MeterCircle.Color;

		type ValueChangedCallback = (args: Self.MeterCircle.ValueChangedCallbackArgs) => void;

		interface ValueChangedCallbackArgs {
			value: number;

			previousValue: number;

			reason: Self.MeterCircle.Reason;

		}

		type ValueAcceptedCallback = (args: Self.MeterCircle.ValueAcceptedCallbackArgs) => void;

		interface ValueAcceptedCallbackArgs {
			acceptedValue: number;

			previousAcceptedValue: number;

			reason: Self.MeterCircle.Reason;

		}

		enum Type {
			CIRCULAR,
			SEMI_CIRCULAR,
		}

		enum Size {
			LARGE,
			MEDIUM,
			SMALL,
		}

		enum Color {
			NEUTRAL,
			INFO,
			SUCCESS,
			WARNING,
			ERROR,
		}

		enum Reason {
			VALUE_CHANGED,
			VALUE_ACCEPTED,
		}

	}

	export class Metric extends PackageCore.Component {
		title: (string | number | PackageCore.Translation);

		metric: (string | number | PackageCore.Translation);

		metadata: (string | number | PackageCore.Translation);

		description: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		children: PackageCore.VDom.Children;

		toolbar: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

	}

	export namespace Metric {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			title: (string | number | PackageCore.Translation);

			metric: (string | number | PackageCore.Translation);

			metadata?: (string | number | PackageCore.Translation);

			description?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			toolbar?: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

		}

	}

	export class Modal extends Self.Window {
		constructor(options: Self.Modal.Options);

		withTitleBar: boolean;

		title: (string | number | PackageCore.Translation);

		titleIcon: Self.Image.Source;

		closeButton: boolean;

		maximizeButton: boolean;

		draggable: boolean;

		size: Self.Modal.Size;

		static createAlert(args: Self.Modal.AlertOptions): Self.Modal;

		static createConfirm(args: Self.Modal.ConfirmOptions): Self.Modal;

		/**
		 * @deprecated
		 */
		static DeprecatedNoOwner: object;

	}

	export namespace Modal {
		interface Options extends Self.Window.Options {
			withTitleBar?: boolean;

			title?: (string | number | PackageCore.Translation);

			titleIcon?: Self.Image.Source;

			maximizeButton?: boolean;

			closeButton?: boolean;

			draggable?: boolean;

			size?: Self.Modal.Size;

		}

		interface AlertOptions extends Self.Modal.Options {
			onOk?: (args: Self.Button.ActionArgs) => void;

		}

		interface ConfirmOptions extends Self.Modal.Options {
			onOk?: (args: Self.Button.ActionArgs) => void;

			onCancel?: (args: Self.Button.ActionArgs) => void;

		}

		export import CloseStrategy = Self.WindowCloseStrategy;

		enum Size {
			DEFAULT,
			SMALL,
			MEDIUM,
			LARGE,
		}

		export import ButtonsJustification = Self.Window.ButtonsJustification;

		export import CloseReason = Self.Window.CloseReason;

		export import State = Self.Window.State;

		export import Event = Self.Window.Event;

		export import GapSize = Self.Window.GapSize;

	}

	export class MultiselectDropdown extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.MultiselectDropdown.Options);

		selectedItems: globalThis.Array<any>;

		dataSource: PackageCore.DataSource;

		activeTagIndex: boolean;

		dropDownOpened: boolean;

		textBox: (Self.TextBox | null);

		picker: (Self.ListBoxPicker.Options | null);

		openDropDownOnClick: boolean;

		openDropDownOnFocus: boolean;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		empty: boolean;

		mandatory: boolean;

		size: Self.MultiselectDropdown.Size;

		onSelectionChanged: (Self.MultiselectDropdown.SelectionChangedCallback | null);

		setSelectedItems(items: (globalThis.Array<any> | any), options?: {reason?: string}): void;

		setActiveTagIndex(index: (number | null)): void;

		add(items: (globalThis.Array<any> | any), options?: {reason?: string}): void;

		remove(items: (globalThis.Array<any> | any), options?: {reason?: string}): void;

		openDropDown(args?: Self.MultiselectDropdown.ReasonObject): void;

		closeDropDown(args?: Self.MultiselectDropdown.ReasonObject): void;

		toggleDropDown(args?: Self.MultiselectDropdown.ReasonObject): void;

		acceptChanges(): void;

		private setPickerSelection(items: (globalThis.Array<any> | null)): void;

		private createTagsBox(): PackageCore.JSX.Element;

		private handleTagsBoxTagRemoved(args: {item: any; reason: (string | symbol)}): void;

		private handleTagsBoxSelectedTagIndexChanged(args: {index: (number | null); item: any; reason: (string | symbol)}): void;

		private createTag(value: object): object;

		private createTextBox(): PackageCore.JSX.Element;

		private handleTextBoxActivated(): void;

		private handleTextBoxTextChanged(args: object): void;

		private createPicker(): Self.Picker;

		private setupPicker(options: object): Self.Picker;

		private createDefaultPicker(options: Self.ListBoxPicker.Options): Self.ListBoxPicker;

		private handlePickerOpening(): void;

		private handlePickerOpened(): void;

		private handlePickerClosing(): void;

		private handlePickerClosed(): void;

		private handlePickerSelectionChanged(args: object): void;

		private createChevron(): PackageCore.JSX.Element;

		private changeSelection(selection: globalThis.Array<any>, args: {reason: (string | symbol)}): void;

		private selectItems(selection: globalThis.Array<any>, addedItems: globalThis.Array<any>): globalThis.Array<any>;

		private unselectItems(selection: globalThis.Array<any>, removedItems: globalThis.Array<any>): globalThis.Array<any>;

		private containsItem(array: globalThis.Array<any>, item: any, comparator: (left: any, right: any) => boolean): boolean;

		private compareSelections(left: globalThis.Array<any>, right: globalThis.Array<any>): boolean;

		static Event: Self.MultiselectDropdown.EventTypes;

	}

	export namespace MultiselectDropdown {
		interface Options extends PackageCore.Component.Options {
			activeTagIndex?: (number | null);

			allowEmpty?: boolean;

			ariaLabel?: string;

			dataSource?: PackageCore.DataSource;

			displayMember?: Self.DataSourceComponent.DisplayMember;

			noDataMessage?: string;

			openDropDownOnClick?: boolean;

			openDropDownOnFocus?: boolean;

			placeholder?: string;

			selectedItems?: globalThis.Array<any>;

			showSelectionBar?: boolean;

			textBoxOptions?: Self.TextBox.Options;

			valueMember?: (string | null);

			mandatory?: boolean;

			tagDisplayMember?: Self.DataSourceComponent.DisplayMember;

			tagMaxWidth?: number;

			picker?: Self.ListBoxPicker.Options;

			size?: Self.MultiselectDropdown.Size;

			onSelectionChanged?: Self.MultiselectDropdown.SelectionChangedCallback;

			comparator?: Self.MultiselectDropdown.ComparatorCallback;

			clearFilterOnFocusOut?: boolean;

		}

		type SelectionChangedCallback = (args: Self.MultiselectDropdown.SelectionChangedArgs, sender: Self.MultiselectDropdown) => void;

		type ComparatorCallback = (left: any, right: any) => boolean;

		interface SelectionChangedArgs {
			values: globalThis.Array<any>;

			previousValues: globalThis.Array<any>;

			reason: Self.MultiselectDropdown.Reason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_ITEMS_CHANGED: string;

			ACTIVE_TAG_INDEX_CHANGED: string;

			PICKER_OPENING: string;

			PICKER_OPENED: string;

			PICKER_CLOSING: string;

			PICKER_CLOSED: string;

		}

		interface SelectiveDataObject {
			addItems?: (any | globalThis.Array<any>);

			removeItems?: (any | globalThis.Array<any>);

			reason?: string;

		}

		interface ReasonObject {
			reason?: string;

		}

		enum VisualStyle {
			STANDALONE,
			EMBEDDED,
			REDWOOD_FIELD,
		}

		enum Reason {
			CALL,
			PICKER_CLOSED,
			AUTO_SUGGEST_DATA_CHANGED,
			COMPONENT_FOCUSED,
			API_INVOKED,
			TAG_REMOVED,
		}

		enum I18N {
			NO_DATA_AVAILABLE,
		}

		export import Size = Self.InputSize;

		export import Tag = Self.MultiselectDropdownTag;

		export import TagsBox = Self.MultiselectDropdownTagsBox;

	}

	export class MultiselectDropdownCell extends Self.GridCell {
		constructor();

		dataSource: PackageCore.DataSource;

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		multiselectDropdown: (Self.MultiselectDropdown | null);

		widgetOptions: (Self.MultiselectDropdown.Options | Self.GridCell.WidgetOptionsCallback<Self.MultiselectDropdown.Options> | null);

		setDataSource(dataSource: (PackageCore.DataSource | null)): void;

	}

	export namespace MultiselectDropdownCell {
	}

	export class MultiselectDropdownColumn extends Self.GridColumn {
		constructor(options: Self.MultiselectDropdownColumn.Options);

		dataSource: (PackageCore.DataSource | null);

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		widgetOptions: (Self.MultiselectDropdown.Options | Self.GridColumn.WidgetOptionsCallback<Self.MultiselectDropdown.Options> | null);

	}

	export namespace MultiselectDropdownColumn {
		interface Options extends Self.GridColumn.Options {
			dataSource?: PackageCore.DataSource;

			displayMember?: Self.DataSourceComponent.DisplayMember;

			widgetOptions?: (Self.MultiselectDropdownColumn.Options | Self.GridColumn.WidgetOptionsCallback<Self.MultiselectDropdownColumn.Options>);

			dataSourceConfigurator?: Self.MultiselectDropdownColumn.DataSourceConfiguratorCallback;

		}

		type DataSourceConfiguratorCallback = (row: Self.GridDataRow) => (PackageCore.DataSource | null);

		export import Cell = Self.MultiselectDropdownCell;

	}

	export class MultiselectDropdownTag extends PackageCore.Component {
		constructor(options?: Self.MultiselectDropdownTag.Options);

		label: string;

		selected: boolean;

		removable: boolean;

		setSelected(value: boolean, options?: object): void;

		select(reason?: string): void;

		unselect(reason?: string): void;

		toggle(reason?: string): void;

		setLabel(label: string): void;

		toggleRemovable(): void;

		setRemovable(value: boolean): void;

		private createLabel(): Self.Text;

		private createRemoveButton(): Self.Image;

		static Event: Self.MultiselectDropdownTag.EventTypes;

	}

	export namespace MultiselectDropdownTag {
		interface Options extends PackageCore.Component.Options {
			clickable?: boolean;

			maxWidth?: number;

			label: (string | number | PackageCore.Translation);

			removable?: boolean;

			removeIconLabel?: (string | number | PackageCore.Translation | null);

			removeIconSize?: number;

			selected?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TOGGLED: string;

			REMOVED: string;

		}

		enum VisualStyle {
			STANDALONE,
			EMBEDDED,
			REDWOOD_FIELD,
		}

		enum ToggledReason {
			CALL,
			CLICK,
		}

		enum I18N {
			REMOVE_ICON_LABEL,
		}

	}

	export class MultiselectDropdownTagsBox extends PackageCore.Component {
		constructor(options?: Self.MultiselectDropdownTagsBox.Options);

		tags: globalThis.Array<any>;

		selectedTagIndex: (number | null);

		setTags(tags: globalThis.Array<any>): void;

		setSelectedTagIndex(index: (number | null), options?: object): void;

		private createTagsBox(): Self.StackPanel;

		private createTag(item: object, index: number): Self.MultiselectDropdownTag;

		private removeTag(index: number): void;

		private handleTagToggled(index: number, args: object): void;

		private scrollToSelectedTag(): void;

		private notifyTagRemoved(item: object, reason: string): void;

		private notifySelectedTagIndexChanged(reason: string): void;

		static TAG_REMOVED_DEFAULT_REASON: string;

		static Event: Self.MultiselectDropdownTagsBox.EventTypes;

	}

	export namespace MultiselectDropdownTagsBox {
		interface Options extends PackageCore.Component.Options {
			tags?: globalThis.Array<any>;

			selectedTagIndex?: (number | null);

			tagMaxWidth?: number;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TAG_REMOVED: string;

			SELECTED_TAG_INDEX_CHANGED: string;

		}

		enum SelectedTagIndexChangedReason {
			DEFAULT,
			TAG_CLICKED,
		}

	}

	export class NavigationDrawer extends PackageCore.Component {
		constructor(options?: Self.NavigationDrawer.Options);

		items: globalThis.Array<Self.NavigationDrawerItem>;

		children: PackageCore.VDom.Children;

		selectedValue: (any | null);

		selectedItem: (Self.NavigationDrawerItem | null);

		collapsed: boolean;

		collapsible: boolean;

		header: (PackageCore.Component | PackageCore.JSX.Element);

		headerAlignment: Self.NavigationDrawer.HeaderAlignment;

		onSelectedValueChanged: Self.NavigationDrawer.SelectedValueChangedCallback;

		width: (number | string | null);

		selectActiveRoute: boolean;

		onBeforeItemSelected: Self.NavigationDrawer.BeforeItemSelectedCallback;

		setSelectedItem(selectedItem: (Self.NavigationDrawerItem | null), options: {reason?: (string | symbol)}): void;

		setSelectedValue(value: any, options: {reason?: (string | symbol)}): void;

		setItems(items: globalThis.Array<Self.NavigationDrawer.ItemOptions>): void;

		visitItems(callback: (item: Self.NavigationDrawerItem) => void): void;

		private setItemIndexes(): void;

		private getCollapseButtonTooltipText(): PackageCore.Translation;

		private renderCollapseButton(): PackageCore.JSX.Element;

		private renderChildren(): globalThis.Array<PackageCore.JSX.Element>;

		private renderChild(child: PackageCore.JSX.Element, level: number, isVisible: boolean): PackageCore.JSX.Element;

		private mapVisibleItems(): void;

		private setFocusIndex(): void;

		static Event: Self.NavigationDrawer.EventTypes;

	}

	export namespace NavigationDrawer {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			collapsed?: boolean;

			collapsible?: boolean;

			items?: globalThis.Array<Self.NavigationDrawer.ItemOptions>;

			selectedValue?: any;

			width?: (number | string);

			selectActiveRoute?: boolean;

			onSelectedValueChanged?: Self.NavigationDrawer.SelectedValueChangedCallback;

			onBeforeItemSelected?: Self.NavigationDrawer.BeforeItemSelectedCallback;

		}

		interface ItemOptions {
			value: any;

			selected?: boolean;

			action?: () => void;

			url?: string;

			route?: (string | PackageCore.Route | Self.Link.Route);

			items?: globalThis.Array<Self.NavigationDrawer.ItemOptions>;

			badge?: (string | number | PackageCore.Translation);

			badgeStatus?: PackageCore.Component.Status;

			enabled?: boolean;

			icon?: Self.Image.Source;

			separatorTop?: boolean;

			separatorBottom?: boolean;

			header?: (PackageCore.Component | PackageCore.JSX.Element);

			headerAlignment?: Self.NavigationDrawer.HeaderAlignment;

		}

		type SelectedValueChangedCallback = (args: Self.NavigationDrawer.SelectedValueChangedCallbackArgs) => void;

		interface SelectedValueChangedCallbackArgs {
			value: any;

			previousValue: any;

			reason: (string | symbol);

		}

		type BeforeItemSelectedCallback = (args: Self.NavigationDrawer.BeforeItemSelectedCallbackArgs) => boolean;

		interface BeforeItemSelectedCallbackArgs {
			value: any;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_VALUE_CHANGED: symbol;

			ITEM_SELECTED: string;

			COLLAPSED: string;

		}

		enum VisualStyle {
			DEFAULT,
			LIGHT,
			DARK,
		}

		enum Reason {
			CALL,
			UPDATE,
			ROUTE_UPDATE,
		}

		enum HeaderAlignment {
			CENTER,
			START,
			END,
			STRETCH,
		}

		export import Item = Self.NavigationDrawerItem;

	}

	export class NavigationDrawerItem extends PackageCore.Component {
		constructor(options?: Self.NavigationDrawerItem.Options);

		items: globalThis.Array<Self.NavigationDrawerItem>;

		children: PackageCore.VDom.Children;

		value: any;

		label: (string | number | PackageCore.Translation);

		url: (string | null);

		/**
		 * @deprecated Use url instead of link
		 */
		link: (string | null);

		route: (string | PackageCore.Route | Self.Link.Route | null);

		action: () => void;

		icon: Self.Image.Source;

		badge: (string | number | PackageCore.Translation);

		badgeStatus: PackageCore.Component.Status;

		selected: boolean;

		highlighted: boolean;

		expanded: boolean;

		dataItem: (Self.NavigationDrawer.ItemOptions);

		parent: (Self.NavigationDrawerItem | null);

		content: (PackageCore.Component | PackageCore.JSX.Element);

		separatorTop: boolean;

		separatorBottom: boolean;

		setSelected(selected: boolean, reason: symbol): void;

		private setExpanded(expanded: boolean, reason: symbol): void;

		update(properties: object): void;

		click(): void;

		isTopLevel(): boolean;

		getTopLevelParent(): Self.NavigationDrawerItem;

		scrollIntoView(alignment?: Self.NavigationDrawerItem.ScrollAlignment): void;

		static Event: Self.NavigationDrawerItem.EventTypes;

	}

	export namespace NavigationDrawerItem {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			value?: any;

			action?: () => void;

			badge?: (string | number | PackageCore.Translation);

			badgeStatus?: PackageCore.Component.Status;

			icon?: Self.Image.Source;

			label?: (string | number | PackageCore.Translation);

			url?: string;

			route?: (string | PackageCore.Route | Self.Link.Route);

			selected?: boolean;

			visible?: boolean;

			separatorTop?: boolean;

			separatorBottom?: boolean;

			content?: (PackageCore.Component | PackageCore.JSX.Element);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			CLICKED: symbol;

			SELECTED: symbol;

			EXPANDED: symbol;

			HIGHLIGHTED: symbol;

		}

		enum ScrollAlignment {
			START,
			END,
			NEAREST,
		}

	}

	export class NetsuiteSystemHeader extends PackageCore.Component {
		constructor(options?: Self.NetsuiteSystemHeader.Options);

		logos: globalThis.Array<PackageCore.JSX.Element>;

		environment: Self.NetsuiteSystemHeader.Environment;

		roleColor: Self.NetsuiteSystemHeader.RoleColor;

	}

	export namespace NetsuiteSystemHeader {
		interface Options extends PackageCore.Component.Options {
			feedbackButtonOptions?: Self.Button.Options;

			helpButtonOptions?: Self.Button.Options;

			logos?: globalThis.Array<PackageCore.JSX.Element>;

			navigationMenuOptions?: Self.NetsuiteSystemHeader.HeaderNavigationOptions;

			quickMenuOptions?: Self.NetsuiteSystemHeader.HeaderMenuOptions;

			roleMenuOptions?: Self.NetsuiteSystemHeader.HeaderMenuOptions;

			searchOptions?: Self.NetsuiteSystemHeader.HeaderSearchOptions;

			languageSelectorOptions?: Self.NetsuiteSystemHeader.LanguageSelectorOptions;

			roleColor?: Self.NetsuiteSystemHeader.RoleColor;

			environment?: Self.NetsuiteSystemHeader.Environment;

		}

		interface HeaderMenuOptions {
			icon?: Self.Image.Source;

			label?: Self.NetsuiteSystemHeader.HeaderMenuLabel;

			menuItems?: globalThis.Array<Self.MenuItem>;

			url?: string;

		}

		interface HeaderSearchOptions {
			options?: Self.SystemSearch.Options;

			systemSearch?: Self.SystemSearch;

			placeholder?: string;

			searchString?: string;

		}

		interface LanguageSelectorOptions {
			languages?: globalThis.Array<Self.NetsuiteSystemHeader.LanguageOption>;

			selectedLanguage?: Self.NetsuiteSystemHeader.LanguageOption;

			onLanguageChange?: () => void;

		}

		interface LanguageOption {
			id?: string;

			value?: string;

		}

		interface HeaderNavigationOptions {
			getDynamicItems?: () => globalThis.Promise<any>;

			items?: globalThis.Array<Self.MenuItem>;

		}

		interface HeaderMenuLabel {
			heading?: string;

			subHeading?: string;

		}

		enum Icons {
			SANDBOX,
			RELEASE_PREVIEW,
			NEXT_PREVIEW,
			HELP,
			FEEDBACK,
			CREATE_NEW_RECORD,
			SIGN_OUT,
			CURRENT_ROLE,
			ROLES,
		}

		enum RoleColor {
			DEFAULT,
			BLACK,
			GRAY,
			BROWN,
			ORANGE,
			MOSS_GREEN,
			GREEN,
			LIGHT_BLUE,
			TURQUOISE,
			PURPLE,
			PINK,
			RED,
		}

		enum Environment {
			PRODUCTION,
			RELEASE_PREVIEW,
			SANDBOX,
			F,
			SNAP,
			DEBUGGER,
		}

	}

	export function PageRoot(props: object): PackageCore.JSX.Element;

	class PageSearch {
		addItem(item: Self.PageSearch.SearchableItem, options: Self.PageSearch.SearchableItemOptions): void;

		addItems(items: globalThis.Array<Self.PageSearch.SearchableItem>, options: Self.PageSearch.SearchableItemOptions): void;

		removeItem(itemId: string): void;

	}

	namespace PageSearch {
		interface SearchableItem {
			id: string;

			label: string;

			action: () => void;

		}

		interface SearchableItemOptions {
			category: Self.SearchItemCategory;

			idProperty?: string;

			actionProperty?: string;

			labelProperty?: string;

			nestedArrayProperty?: string;

		}

	}

	export class Pagination extends PackageCore.Component {
		constructor(options?: Self.Pagination.Options);

		selectedPageIndex: number;

		selectedPage: object;

		pages: Self.Pagination.Pages;

		pageItems: globalThis.Array<object>;

		rows: (object | null);

		rowsPerPage: (number | null);

		rowsCount: (number | null);

		rowsPerPageSelector: (Self.Pagination.RowsPerPageSelectorObject | null);

		navigation: (Self.Pagination.Navigation | null);

		rowsCounter: (Self.Pagination.RowsCounter | number | string | null);

		loadMore: (number | null);

		onPageSelected: (Self.Pagination.PageSelectedCallback | null);

		setSelectedPageIndex(pageIndex: number, options?: Self.Pagination.SetterOptions): void;

		setRowsPerPage(rowsPerPage: number, options?: Self.Pagination.SetterOptions): void;

		setRowsCount(rowsCount: number, options: Self.Pagination.SetterOptions): void;

		setPages(pages: Self.Pagination.Pages, options: Self.Pagination.SetterOptions): void;

		private handlePaginationChanged(reason?: symbol, oldProperties?: object): void;

		private parsePages(pages: Self.Pagination.Pages): void;

		private parseRowsSettings(pages: Self.Pagination.Pages): (object | null);

		private parsePagesSettings(pages: Self.Pagination.Pages): globalThis.Array<object>;

		private parsePagesNumber(pageNumber: number): globalThis.Array<object>;

		private parsePagesArray(pageArray: (globalThis.Array<string> | globalThis.Array<object>)): globalThis.Array<object>;

		private parsePagesObject(pageObject: object): globalThis.Array<object>;

		private renderLayout(): globalThis.Array<PackageCore.Component>;

		private renderRowsPerPageSelector(): (Self.StackPanel | null);

		private renderRowsPerPageSelectorTextBox(): Self.TextBox;

		private renderRowsPerPageSelectorDropdown(): Self.Dropdown;

		private renderRowsPerPageSelectorDropdownData(): PackageCore.ArrayDataSource;

		private renderNavigation(): (Self.StackPanel | null);

		private renderNavigationSegmentation(): (Self.StackPanel | null);

		private renderNavigationPageIndicator(): (Self.Text | Self.TextBox | Self.Dropdown | null);

		private renderNavigationPageIndicatorEditable(): (Self.TextBox | Self.Dropdown);

		private renderNavigationPageIndicatorDropdown(): Self.Dropdown;

		private renderNavigationPageIndicatorTextBox(): Self.TextBox;

		private renderNavigationPageIndicatorStatic(): Self.Text;

		private handleNavigationPageIndicatorTextBoxEdited(args: object): void;

		private renderNavigationButtons(): (Self.StackPanel | null);

		private renderNavigationTotal(): (Self.Text | Self.Button);

		private renderNavigationTotalLabel(): string;

		private renderNavigationTotalButton(label: string, firstPage: boolean, lastPage: boolean): Self.Button;

		private renderNavigationTotalText(label: string): Self.Text;

		private renderNavigationButtonsList(): (Self.List | null);

		private renderNavigationButtonPrevious(): Self.Button;

		private renderNavigationButtonNext(): Self.Button;

		private renderNavigationPageList(): globalThis.Array<PackageCore.JSX.Element>;

		private handleNavigationPageListClick(pageIndex: number): void;

		private renderRowsCounter(): (Self.Text | null);

		private renderRowsCounterTotal(number?: number): Self.Text;

		private renderRowsCounterTotalText(number?: any): string;

		private renderRowsCounterComplete(): Self.Text;

		private renderRowsCounterCompleteText(): string;

		private renderRowsCounterUnknown(): Self.Text;

		private renderRowsCounterUnknownText(): string;

		private renderRowsCounterCustom(): Self.Text;

		private renderLoadMoreButton(): (Self.Button | null);

		private handleLoadMoreButtonClick(): void;

		private notifySelectedPageIndexChanged(previousIndex: number, reason: string): void;

		private parseNavigationSettings(navigation: Self.Pagination.Navigation): (Self.Pagination.Navigation | null);

		private parseLegacyNavigationSettings(navigation: object): void;

		static default(pages: Self.Pagination.Pages, options?: Self.Pagination.Options): Self.Pagination;

		static Default(props: Self.Pagination.Options): Self.Pagination;

		static withTotal(pages: Self.Pagination.Pages, options?: Self.Pagination.Options): Self.Pagination;

		static WithTotal(props: Self.Pagination.Options): Self.Pagination;

		static editable(pages: Self.Pagination.Pages, options?: Self.Pagination.Options): Self.Pagination;

		static Editable(props: Self.Pagination.Options): Self.Pagination;

		static segmentation(pages: Self.Pagination.Pages, options?: Self.Pagination.Options): Self.Pagination;

		static Segmentation(props: Self.Pagination.Options): Self.Pagination;

		static pageIndicatorSegmentation(pages: Self.Pagination.Pages, options?: Self.Pagination.Options): Self.Pagination;

		static PageIndicatorSegmentation(props: Self.Pagination.Options): Self.Pagination;

		static pageList(pages: Self.Pagination.Pages, options?: Self.Pagination.Options): Self.Pagination;

		static PageList(props: Self.Pagination.Options): Self.Pagination;

		static Event: Self.Pagination.EventTypes;

	}

	export namespace Pagination {
		type Pages = (number | Self.Pagination.RowsObject | globalThis.Array<string> | globalThis.Array<object>);

		interface RowsObject {
			rowsCount: number;

			rowsPerPage: number;

		}

		interface RowsPerPageSelectorObject {
			all?: boolean;

			data?: globalThis.Array<number>;

			type: Self.Pagination.RowsPerPageSelector;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_PAGE_CHANGED: symbol;

			PAGINATION_CHANGED: symbol;

		}

		interface Navigation {
			buttons?: (Self.Pagination.NavigationButtons | boolean);

			pageIndicator?: (Self.Pagination.NavigationPageIndicator | boolean);

			pageList?: boolean;

			segmentation?: boolean;

			type: Self.Pagination.NavigationType;

			segmentationWidth?: (number | string);

		}

		interface NavigationPageIndicator {
			editable: boolean;

		}

		interface NavigationButtons {
			firstPage?: boolean;

			previousPage?: boolean;

			nextPage?: boolean;

			lastPage?: boolean;

			total?: boolean;

		}

		interface SetterOptions {
			reason?: symbol;

			focus?: NavigationPageListElement;

		}

		interface Options extends PackageCore.Component.Options {
			pages?: Self.Pagination.Pages;

			rowsPerPageSelector?: Self.Pagination.RowsPerPageSelectorObject;

			navigation?: Self.Pagination.Navigation;

			rowsCounter?: (Self.Pagination.RowsCounter | number | string);

			loadMore?: number;

			order?: globalThis.Array<Self.Pagination.Section>;

			selectedPageIndex?: number;

			onPageSelected?: Self.Pagination.PageSelectedCallback;

		}

		type PageSelectedCallback = (args: Self.Pagination.PageSelectedArgs, sender: Self.Pagination) => void;

		interface PageSelectedArgs {
			page: any;

			index: number;

			previousPage: any;

			previousIndex: number;

			reason: Self.Pagination.Reason;

		}

		enum RowsCounter {
			COMPLETE,
			TOTAL,
			UNKNOWN,
			CUSTOM,
			NONE,
		}

		enum RowsPerPageSelector {
			INPUT,
			LIST,
		}

		enum Reason {
			UPDATE,
			CALL,
		}

		enum NavigationType {
			PAGE,
			ROWS_RANGE,
		}

		enum NavigationPageListElement {
			PREVIOUS,
			NEXT,
			CURRENT,
		}

		enum I18N {
			OF,
			TOTAL,
			UNKNOWN,
			SHOW,
			GO_TO,
			LOAD_MORE,
			ALL,
			FIRST_PAGE,
			PREVIOUS_PAGE,
			NEXT_PAGE,
			LAST_PAGE,
		}

		enum Section {
			ROWS_PER_PAGE_SELECTOR,
			NAVIGATION,
			ROWS_COUNTER,
			LOAD_MORE_BUTTON,
		}

		enum VisualStyle {
			STANDALONE,
			EMBEDDED,
		}

	}

	export class Paragraph extends PackageCore.Component {
		constructor(options?: Self.Paragraph.Options);

		content: (string | PackageCore.Component | globalThis.Array<(string | PackageCore.Component)>);

		children: PackageCore.VDom.Children;

		type: Self.Paragraph.Type;

		textAlignment: Self.Paragraph.TextAlignment;

		setType(type: Self.Paragraph.Type): void;

		setContent(content: (string | PackageCore.Component | globalThis.Array<(string | PackageCore.Component)>)): void;

	}

	export namespace Paragraph {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (null | string | PackageCore.Translation | PackageCore.Component | globalThis.Array<(string | PackageCore.Translation | PackageCore.Component)>);

			textAlignment?: Self.Paragraph.TextAlignment;

			type?: Self.Paragraph.Type;

		}

		enum Type {
			REGULAR,
			SMALL,
			LEAD,
			BOLD,
			WEAK,
		}

		enum TextAlignment {
			LEFT,
			CENTER,
			RIGHT,
			JUSTIFY,
		}

		enum VisualStyle {
			STANDALONE,
			EMBEDDED,
			REDWOOD_FIELD,
		}

	}

	export class Picker implements PackageCore.EventSource, PackageCore.MessageHandler {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options?: Self.Picker.Options);

		window: Self.Window;

		content: PackageCore.Component;

		opened: boolean;

		open(args?: object): void;

		close(args?: object): void;

		resize(args?: object): void;

		dispose(): void;

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

		setInputAttribute(name: string, value: string): void;

		removeInputAttribute(name: string): void;

		private _changeSelection(args?: object): void;

		private _openWindow(args: (object | null)): void;

		protected _createContent(args: object): PackageCore.Component;

		private _createWindow(): Self.Window;

		private _nextToken(): object;

		private _handleWindowOpening(): void;

		private _handleWindowOpened(): void;

		private _handleWindowClosing(): void;

		private _handleWindowClosed(): void;

		private _handlePickerUpdated(): void;

		static Event: Self.Picker.EventTypes;

	}

	export namespace Picker {
		interface Options {
			window?: Omit<Self.Popover.Options, "owner">;

			openConfiguration?: (options: Self.Window.OpenArgs) => Self.Window.OpenArgs;

			owner?: PackageCore.Component;

			input?: PackageCore.Component;

			on?: PackageCore.EventSource.ListenerMap;

		}

		interface EventTypes {
			OPENING: string;

			OPENED: string;

			CLOSING: string;

			CLOSED: string;

			SELECTION_CHANGED: string;

			UPDATED: string;

		}

		enum Reason {
			CALL,
			DISPOSE,
			ESC,
			ENTER,
			UPDATE,
			CLEAR,
		}

		export import CloseReason = Self.WindowCloseReason;

	}

	export class Placeholder extends PackageCore.Component {
		constructor(options?: Self.Placeholder.Options);

		text: Self.Kpi.Color;

	}

	export namespace Placeholder {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			text: string;

		}

	}

	export class Popover extends Self.Window {
		constructor(options: Self.Popover.Options);

		closeButton: boolean;

		size: Self.Popover.Size;

		static withOk(args: Self.Popover.Options): Self.Popover;

		static createAlert(args: Self.Popover.AlertOptions): Self.Popover;

		static createConfirm(args: Self.Popover.ConfirmOptions): Self.Popover;

		static DefaultPlacementOffset: number;

	}

	export namespace Popover {
		interface Options extends Self.Window.Options {
			closeButton?: boolean;

			size?: Self.Popover.Size;

		}

		interface AlertOptions extends Self.Popover.Options {
			onOk?: Self.Button.ActionCallback;

		}

		interface ConfirmOptions extends Self.Popover.Options {
			onOk?: Self.Button.ActionCallback;

			onCancel?: Self.Button.ActionCallback;

		}

		enum Size {
			DEFAULT,
			SMALL,
			MEDIUM,
			MAX_SMALL,
			MAX_MEDIUM,
		}

		export import ButtonsJustification = Self.Window.ButtonsJustification;

		export import CloseStrategy = Self.WindowCloseStrategy;

		export import CloseReason = Self.Window.CloseReason;

		export import Event = Self.Window.Event;

		export import GapSize = Self.Window.GapSize;

		export import Position = Self.Window.Position;

	}

	export class Portlet extends PackageCore.Component {
		constructor(options?: Self.Portlet.Options);

		title: string;

		description: string;

		icon: Self.Image.Source;

		color: Self.Portlet.Color;

		content: (PackageCore.Component | PackageCore.JSX.Element);

		controls: globalThis.Array<(Self.Button.Options | Self.MenuButton.Options)>;

		collapsible: boolean;

		collapsed: boolean;

		children: PackageCore.VDom.Children;

		hasHeader: boolean;

		static Event: Self.Portlet.EventTypes;

	}

	export namespace Portlet {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			title?: (string | number | PackageCore.Translation);

			description?: (string | number | PackageCore.Translation);

			icon?: Self.Image.Source;

			color?: Self.Portlet.Color;

			controls?: globalThis.Array<(Self.Button.Options | Self.MenuButton.Options)>;

			collapsible?: boolean;

			collapsed?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			COLLAPSED: string;

		}

		enum Color {
			NONE,
			NEUTRAL,
			SUCCESS,
			WARNING,
			DANGER,
			INFO,
			TEAL,
			ORANGE,
			TURQUOISE,
			TAUPE,
			GREEN,
			PINK,
			BROWN,
			LILAC,
			YELLOW,
			PURPLE,
			BLUE,
			PINE,
			THEMED,
		}

	}

	class ProjectParser {
		constructor();

	}

	namespace ProjectParser {
	}

	export class PromotionService {
	}

	export namespace PromotionService {
	}

	export class RadioButton extends PackageCore.Component {
		constructor(options?: Self.RadioButton.Options);

		label: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element | null);

		/**
		 * @deprecated
		 */
		radio: Self.RadioButton;

		labelPosition: Self.RadioButton.LabelPosition;

		value: (boolean | null);

		clickableLabel: boolean;

		readOnly: boolean;

		emptyLabel: boolean;

		group: (Self.RadioGroup | null);

		action: (Self.RadioButton.ActionCallback | null);

		data: any;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		setValue(value: (boolean | null), options?: {reason?: string}): void;

		setLabel(label: string): void;

		setLabelPosition(value: Self.RadioButton.LabelPosition): void;

		setGroup(group: Self.RadioGroup): void;

		static Event: Self.RadioButton.EventTypes;

	}

	export namespace RadioButton {
		interface Options extends PackageCore.Component.Options {
			clickableLabel?: boolean;

			group?: Self.RadioGroup;

			label?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			labelPosition?: Self.RadioButton.LabelPosition;

			value?: boolean;

			action?: Self.RadioButton.ActionCallback;

			data?: any;

			readOnly?: boolean;

		}

		type ActionCallback = (args: Self.RadioButton.ActionArgs, sender: Self.RadioButton) => void;

		interface ActionArgs {
			value: boolean;

			previousValue: boolean;

			reason: string;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TOGGLED: string;

		}

		enum VisualStyle {
			DEFAULT,
		}

		enum LabelPosition {
			LEFT,
			RIGHT,
			ABOVE,
			BELOW,
		}

		enum Reason {
			CLICK,
			KEY_PRESS,
		}

		export import Group = Self.RadioButtonGroup;

	}

	export class RadioButtonGroup extends PackageCore.Component {
		constructor(options?: Self.RadioButtonGroup.Options);

		children: PackageCore.VDom.Children;

		selectedData: any;

		columnGap: Self.RadioButtonGroup.GapSize;

		rowGap: Self.RadioButtonGroup.GapSize;

		columns: (number | string | globalThis.Array<string>);

		rows: (number | string | globalThis.Array<string>);

		gridOptions: Self.GridPanel.Options;

		onSelectionChanged: (Self.RadioButtonGroup.SelectionChangedCallback | null);

		private renderChild(child: PackageCore.JSX.Element): PackageCore.JSX.Element;

		private removeFromGroup(ref: PackageCore.VDom.Ref): void;

		private handleToggled(value: boolean, data: any, reason: (string | symbol)): void;

		private handleSelectedItemChanged(previousData: any, data: any, reason: (string | symbol)): void;

		static Event: Self.RadioButtonGroup.EventTypes;

		static Horizontal(props: Self.RadioButtonGroup.Options): PackageCore.JSX.Element;

		static Vertical(props: Self.RadioButtonGroup.Options): PackageCore.JSX.Element;

	}

	export namespace RadioButtonGroup {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			columns?: (number | string | globalThis.Array<string>);

			rows?: (number | string | globalThis.Array<string>);

			columnGap?: (number | string | globalThis.Array<string>);

			rowGap?: (number | string | globalThis.Array<string>);

			gridOptions?: Self.GridPanel.Options;

			defaultItemOptions?: Self.RadioButton.Options;

			onSelectionChanged?: Self.RadioButtonGroup.SelectionChangedCallback;

		}

		type SelectionChangedCallback = (args: Self.RadioButtonGroup.SelectionChangedArgs, sender: Self.RadioButtonGroup) => void;

		interface SelectionChangedArgs {
			data: any;

			previousData: any;

			reason: (string | symbol);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_ITEM_CHANGED: string;

		}

		export import GapSize = Self.GapSize;

	}

	export class RadioGroup implements PackageCore.EventSource {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options?: Self.RadioGroup.Options);

		guid: string;

		buttons: globalThis.Array<Self.RadioButton>;

		selectedButton: (Self.RadioButton | null);

		add(button: Self.RadioButton): Self.RadioGroup;

		remove(button: Self.RadioButton): void;

		focusNext(button: Self.RadioButton, direction: number): boolean;

		static Event: Self.RadioGroup.EventTypes;

	}

	export namespace RadioGroup {
		interface Options {
			tabbable?: boolean;

			onToggled?: Self.RadioGroup.ToggledCallback;

			on?: PackageCore.EventSource.ListenerMap;

		}

		type ToggledCallback = (args: Self.RadioGroup.ToggledArgs, sender: Self.RadioGroup) => void;

		interface ToggledArgs {
			button: Self.RadioButton;

			previousButton: Self.RadioButton;

			value: boolean;

			previousValue: boolean;

			data: any;

			reason: any;

		}

		interface EventTypes {
			BUTTON_REMOVED: string;

			BUTTON_ADDED: string;

			BUTTON_TOGGLED: string;

		}

		enum Reason {
			RADIO_GROUP_DESELECT,
		}

	}

	export class RadioGroupPicker extends Self.Picker {
		constructor(options: Self.RadioGroupPicker.Options);

		dataSource: PackageCore.DataSource;

		radioGroup: Self.RadioGroup;

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		valueMember: (Self.DataSourceComponent.ValueMember | null);

		private handleSelectionChanged(item: any, args: Self.RadioButton.ActionArgs): void;

		private forwardMessageToGroup(message: PackageCore.RoutedMessage, result: object): void;

		private selectFirst(topOrBottom: number): void;

		private getDisplayMember(dataItem: object): any;

		private updateContent(selection: any, searchPhrase?: string): void;

		private createPlaceholder(): void;

		private createRadioButton(group: Self.RadioGroup, item: any, value: boolean): void;

		private applySelection(selection: any): void;

	}

	export namespace RadioGroupPicker {
		interface Options extends Self.Picker.Options {
			dataSource: PackageCore.DataSource;

			displayMember?: Self.DataSourceComponent.DisplayMember;

			valueMember?: Self.DataSourceComponent.ValueMember;

			comparator?: (left: any, right: any) => boolean;

			searchMember?: Self.DataSourceComponent.DisplayMember;

			noDataMessage?: (string | PackageCore.Translation);

			search?: (Self.RadioGroupPicker.SearchBoxPredicate | Self.RadioGroupPicker.SearchBoxOptions);

		}

		type SearchBoxPredicate = (value: any, phrase: string) => boolean;

		interface SearchBoxOptions {
			predicate?: Self.RadioGroupPicker.SearchBoxPredicate;

			textBox?: Self.TextBox.Options;

		}

	}

	export class RadioList {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		onPropertyChanged(propertyName?: string, callback?: (args: PackageCore.PropertyObservable.EventArgs, sender: any) => void): any;

		protected _notifyPropertyChanged(propertyName: string, oldValue: any, newValue: any, reason?: (string | null)): void;

		constructor(options: object);

		data: globalThis.Array<any>;

		radios: globalThis.Array<Self.RadioButton>;

		group: Self.RadioGroup;

		selectedValue: any;

		selectedItem: any;

		selectedRadio: Self.RadioButton;

		attachRadiosTo(element: HTMLElement): void;

		setSelectedValue(value: any): void;

		itemForValue(value: any): (any | null);

		radioForValue(value: any): (Self.RadioButton | null);

		static Event: Self.RadioList.EventTypes;

	}

	export namespace RadioList {
		interface EventTypes {
			TOGGLED: string;

		}

	}

	export class Ratings extends PackageCore.Component {
		constructor(options?: Self.Ratings.Options);

		rating: number;

		imageSize: Self.Ratings.ImageSize;

		imageVariant: Self.Ratings.ImageVariant;

		mode: Self.Ratings.Mode;

		quantity: Self.Ratings.Quantity;

		tooltips: globalThis.Array<(PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | null)>;

		readOnly: boolean;

		color: Self.Ratings.Color;

		onRatingChanged: (Self.Ratings.RatingChangedCallback | null);

		setRating(value: number, args?: {reason?: (string | symbol)}): void;

		setColor(color: Self.Ratings.Color): void;

		setReadOnly(readOnly: boolean): void;

		private _createIconPairs(quantity: Self.Ratings.Quantity, imageVariant: Self.Ratings.ImageVariant, tooltips: globalThis.Array<(PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | null)>): globalThis.Array<Self.Ratings.IconPair>;

		private _createRawIconPairs(quantity: Self.Ratings.Quantity, imageVariant: Self.Ratings.ImageVariant): globalThis.Array<Self.Ratings.IconPair>;

		private _createImage(index: number, icons: Self.Ratings.IconPair): PackageCore.JSX.Element;

		static Event: Self.Ratings.EventTypes;

	}

	export namespace Ratings {
		interface Options extends PackageCore.Component.Options {
			color?: Self.Ratings.Color;

			imageSize?: Self.Ratings.ImageSize;

			imageVariant?: Self.Ratings.ImageVariant;

			mode?: Self.Ratings.Mode;

			quantity?: Self.Ratings.Quantity;

			rating?: number;

			defaultRating?: number;

			readOnly?: boolean;

			tooltips?: globalThis.Array<(PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | null)>;

			onRatingChanged?: Self.Ratings.RatingChangedCallback;

		}

		type RatingChangedCallback = (args: Self.Ratings.RatingChangedArgs, sender: Self.Ratings) => void;

		interface RatingChangedArgs {
			value: number;

			previousValue: number;

			reason: Self.Ratings.Reason;

		}

		interface IconPair {
			filled: PackageCore.ImageMetadata;

			outline: PackageCore.ImageMetadata;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			RATING_CHANGED: string;

		}

		enum Quantity {
			THREE,
			FOUR,
			FIVE,
		}

		enum Mode {
			FULL,
			SINGLE,
		}

		enum ImageVariant {
			STAR,
			HEART,
			FACE,
			NUMBER,
		}

		enum ImageSize {
			M,
			L,
			XL,
		}

		enum Color {
			NEUTRAL,
			SUCCESS,
			WARNING,
			DANGER,
			INFO,
			ACCENT,
			ERROR,
			DEFAULT,
		}

		enum I18n {
			POOR,
			OKAY,
			GOOD,
			GREAT,
			EXCELLENT,
		}

		enum Reason {
			KEY,
			CLICK,
			CALL,
		}

	}

	export class RecordInfoPortlet extends PackageCore.Component {
		constructor(options?: Self.RecordInfoPortlet.Options);

	}

	export namespace RecordInfoPortlet {
		interface Options extends PackageCore.Component.Options {
		}

	}

	export class Reminder extends PackageCore.Component {
		constructor(options?: Self.Reminder.Options);

		color: Self.Reminder.Color;

		count: (string | number | PackageCore.Translation | null);

		description: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		layout: Self.Reminder.Layout;

	}

	export namespace Reminder {
		interface Options extends PackageCore.Component.Options {
			color?: Self.Reminder.Color;

			description: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			count?: (string | number | PackageCore.Translation | null);

			layout?: Self.Reminder.Layout;

		}

		enum Layout {
			HEADLINE,
			INLINE,
		}

		enum Color {
			NEUTRAL,
			SUCCESS,
			WARNING,
			DANGER,
			INFO,
			TEAL,
			ORANGE,
			TURQUOISE,
			TAUPE,
			GREEN,
			PINK,
			BROWN,
			LILAC,
			YELLOW,
			PURPLE,
			BLUE,
			PINE,
			THEMED,
		}

	}

	export class ReminderPortlet extends PackageCore.Component {
		constructor(options?: Self.ReminderPortlet.Options);

	}

	export namespace ReminderPortlet {
		interface Options extends PackageCore.Component.Options {
		}

	}

	export class ResponsivePanel extends PackageCore.Component {
		constructor(options: Self.ResponsivePanel.Options);

		content: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<Self.ResponsivePanel.ItemObject> | null);

		children: PackageCore.VDom.Children;

		widthBreakpoint: (Self.ResponsivePanel.BreakpointKey | null);

		widthBreakpoints: Record<Self.ResponsivePanel.BreakpointKey, number>;

		heightBreakpoint: (Self.ResponsivePanel.BreakpointKey | null);

		heightBreakpoints: Record<Self.ResponsivePanel.BreakpointKey, number>;

		private parseChildren(children: PackageCore.VDom.Children): globalThis.Array<PackageCore.JSX.Element>;

		private parseContent(content: (PackageCore.JSX.Element | PackageCore.Component | globalThis.Array<Self.ResponsivePanel.ItemObject>)): globalThis.Array<PackageCore.JSX.Element>;

		private parseBreakpoints(breakpoints: Record<Self.ResponsivePanel.BreakpointKey, number>): globalThis.Map<Self.ResponsivePanel.BreakpointKey, number>;

		private getBreakpoint(size: number, breakpoints: Self.ResponsivePanel.BreakpointKey): (Self.ResponsivePanel.BreakpointKey | null);

		private updateWidthBreakpoint(): void;

		private updateHeightBreakpoint(): void;

		private renderItem(): PackageCore.JSX.Element;

		static WidthBreakpointContext: string;

		static HeightBreakpointContext: string;

		static Event: Self.ResponsivePanel.EventTypes;

		static Item(props?: {children?: PackageCore.VDom.Children}): PackageCore.JSX.Element;

	}

	export namespace ResponsivePanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (PackageCore.Component | PackageCore.JSX.Element);

			widthBreakpoints?: Record<string, number>;

			heightBreakpoints?: Record<string, number>;

		}

		type BreakpointKey = string;

		interface ItemObject {
			component: (PackageCore.Component | PackageCore.JSX.Element);

			minWidth: Self.ResponsivePanel.BreakpointKey;

			maxWidth: Self.ResponsivePanel.BreakpointKey;

			width: Self.ResponsivePanel.BreakpointKey;

			minHeight: Self.ResponsivePanel.BreakpointKey;

			maxHeight: Self.ResponsivePanel.BreakpointKey;

			height: Self.ResponsivePanel.BreakpointKey;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			WIDTH_BREAKPOINT_CHANGED: string;

			HEIGHT_BREAKPOINT_CHANGED: string;

		}

		enum Breakpoint {
			XXL,
			XL,
			LG,
			MD,
			SM,
			XS,
		}

		enum BootstrapBreakpoint {
			XXL,
			XL,
			LG,
			MD,
			SM,
			XS,
		}

		enum BootstrapBreakpoints {
		}

	}

	export class RichTextEditor extends PackageCore.Component {
		constructor(options: Self.RichTextEditor.Options);

		text: string;

		empty: boolean;

		placeholder: string;

		maxLength: number;

		maxLengthIndicator: boolean;

		resizable: boolean;

		editorMode: Self.RichTextEditor.EditorMode;

		onTextChanged: (Self.RichTextEditor.TextChangedCallback | null);

		bloom: boolean;

		setText(text: string, options?: object): void;

		insertText(text: string): void;

		setMaxLength(maxLength: number): void;

		setMaxLengthIndicator(value: boolean): void;

		setEditorMode(editorMode: Self.RichTextEditor.EditorMode): void;

		resize(width: (number | string), height: (number | string)): void;

		getEditableElement(): void;

		static Event: Self.RichTextEditor.EventTypes;

	}

	export namespace RichTextEditor {
		interface Options extends PackageCore.Component.Options {
			text?: string;

			maxLength?: (number | null);

			maxLengthIndicator?: boolean;

			placeholder?: (string | PackageCore.Translation);

			allowedHtmlTags?: RegExp;

			allowChangeEditorMode?: boolean;

			editorMode?: EditorMode;

			width?: (number | string);

			height?: (number | string);

			resizable?: boolean;

			resizeDirection?: Self.RichTextEditor.ResizeDirection;

			defaultFontFamily?: string;

			defaultFontSize?: number;

			onTextChanged?: Self.RichTextEditor.TextChangedCallback;

			bloom?: boolean;

			contentToolbar?: (PackageCore.Component | PackageCore.JSX.Element);

		}

		type TextChangedCallback = (args: Self.RichTextEditor.TextChangedArgs, sender: Self.RichTextEditor) => void;

		interface TextChangedArgs {
			text: string;

			previousText: string;

			reason: Self.RichTextEditor.TextChangeReason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TEXT_CHANGED: string;

			EDITOR_RESIZED: string;

			EDITOR_MODE_CHANGED: string;

			SELECTION_CHANGED: string;

		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
			REDWOOD_FIELD,
		}

		enum ResizeDirection {
			BOTH,
			HORIZONTAL,
			VERTICAL,
		}

		enum FontFamily {
			ARIAL,
			COMIC_SANS,
			GEORGIA,
			GOTHIC,
			MYRIAD,
			OPEN_SANS,
			TAHOMA,
			TIMES_NEW_ROMAN,
			TREBUCHET,
			VERDANA,
		}

		enum EditorMode {
			SOURCE,
			WYSIWYG,
		}

		enum TextChangeReason {
			INPUT,
		}

	}

	class RowResizer implements PackageCore.MessageHandler {
		constructor();

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

	}

	namespace RowResizer {
	}

	class ScrollButton extends PackageCore.Component {
		constructor(options: Self.ScrollButton.Options);

	}

	namespace ScrollButton {
		interface Options extends PackageCore.Component.Options {
			buttonOptions: Self.Button.Options;

			background: boolean;

		}

	}

	export function ScrollLayout(props?: {topContent?: (PackageCore.Component | PackageCore.JSX.Element | null); children?: PackageCore.VDom.Children}): PackageCore.JSX.Element;

	export class ScrollPanel extends PackageCore.Component {
		constructor(options: Self.ScrollPanel.Options);

		scrollController: PackageCore.ScrollController;

		scrollOffset: PackageCore.Scrollable.Offset;

		viewportSize: PackageCore.Scrollable.Size;

		contentSize: PackageCore.Scrollable.Size;

		orientation: Self.ScrollPanel.Orientation;

		content: (PackageCore.Component | PackageCore.JSX.Element | null);

		children: PackageCore.VDom.Children;

		element: Self.ScrollPanel.Element;

		scrollControl: Self.ScrollPanel.ScrollControl;

		scrollControlPosition: Self.ScrollPanel.ScrollControlPosition;

		scrollAmount: number;

		hoverScrollAmount: number;

		hoverScrollRepeat: number;

		hoverScrolls: boolean;

		autoHideButtons: Self.ScrollPanel.AutoHide;

		decorator: (PackageCore.Decorator | null);

		setContent(content: PackageCore.Component): void;

		setOrientation(orientation: Self.ScrollPanel.Orientation): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		scrollIntoView(args: {element: Element; reason?: string}): void;

		scroll(): boolean;

		scrollToTop(options?: {reason?: any}): boolean;

		scrollToBottom(options?: {reason?: any}): boolean;

		private _createScrollButtons(): void;

		static horizontal(options?: Self.ScrollPanel.Options): Self.ScrollPanel;

		static Horizontal(): PackageCore.JSX.Element;

		static vertical(options?: Self.ScrollPanel.Options): Self.ScrollPanel;

		static Vertical(): PackageCore.JSX.Element;

	}

	export namespace ScrollPanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			allowWheelPassThrough?: boolean;

			content?: (PackageCore.Component | PackageCore.JSX.Element);

			decorator?: PackageCore.Decorator;

			hoverScrolls?: boolean;

			autoHideButtons?: Self.ScrollPanel.AutoHide;

			orientation?: Self.ScrollPanel.Orientation;

			scrollControlPosition?: Self.ScrollPanel.ScrollControlPosition;

			scrollControl?: Self.ScrollPanel.ScrollControl;

			scrollAmount?: number;

			hoverScrollAmount?: number;

			hoverScrollRepeat?: number;

			element?: Self.ScrollPanel.Element;

			onScrollabilityChanged?: Self.ScrollPanel.ScrollabilityChangedCallback;

		}

		type ScrollabilityChangedCallback = (args: Self.ScrollPanel.ScrollabilityChangedCallbackArgs) => void;

		interface ScrollabilityChangedCallbackArgs {
			value: PackageCore.Scrollable.Scrollability;

			previousValue: PackageCore.Scrollable.Scrollability;

			reason: any;

		}

		enum ScrollControl {
			BAR,
			BUTTON,
		}

		enum Orientation {
			VERTICAL,
			HORIZONTAL,
			BOTH,
		}

		enum ScrollControlPosition {
			SIDE_CONTENT,
			OVER_CONTENT,
		}

		enum AutoHide {
			NONE,
			OWN_SCROLLABLE,
			AXIS_SCROLLABLE,
			ANY_SCROLLABLE,
		}

		export import Element = PackageCore.Html.Element.Section;

	}

	export class ScrollTabList extends PackageCore.Component {
		constructor(options?: Self.ScrollTabList.Options);

		tabs: globalThis.Array<Self.Tab>;

		children: PackageCore.VDom.Children;

		reorder: boolean;

		justification: Self.ScrollTabList.Justification;

		tabSpacer: (boolean | null);

		position: Self.ScrollTabList.Position;

		stripePosition: Self.ScrollTabList.StripePosition;

		horizontal: boolean;

		hierarchy: Self.ScrollTabList.Hierarchy;

		divider: boolean;

		selectedValue: Self.Tab;

		decorator: (PackageCore.Decorator | null);

		tabIndex(tab: Self.Tab): (number | null);

		setPosition(position: Self.ScrollTabList.Position): void;

		setStripePosition(position: Self.ScrollTabList.StripePosition): void;

		setHierarchy(hierarchy: Self.ScrollTabList.Hierarchy): void;

		setJustification(justification: Self.ScrollTabList.Justification): void;

		setTabSpacer(value: (boolean | null)): void;

		move(item: Self.Tab, options?: {index: number; reason?: string}): void;

	}

	export namespace ScrollTabList {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			position?: Self.ScrollTabList.Position;

			stripePosition?: Self.ScrollTabList.StripePosition;

			justification?: Self.ScrollTabList.Justification;

			hierarchy?: Self.ScrollTabList.Hierarchy;

			divider?: boolean;

			reorder?: boolean;

			tabSpacer?: boolean;

			decorator?: PackageCore.Decorator;

			items?: globalThis.Array<Self.Tab>;

		}

		export import VisualStyle = Self.TabPanelOptions.VisualStyle;

		export import Position = Self.TabPanelOptions.TabPosition;

		export import StripePosition = Self.TabPanelOptions.TabStripePosition;

		export import Justification = Self.TabPanelOptions.TabJustification;

		export import Hierarchy = Self.TabPanelOptions.Hierarchy;

	}

	export class Scrollbar extends PackageCore.Component {
		constructor();

		scrollController: PackageCore.ScrollController;

		trackSize: number;

		contentSize: PackageCore.Scrollable.Size;

		viewportSize: PackageCore.Scrollable.Size;

		scrollOffset: number;

		maxScrollOffset: number;

		autoHide: boolean;

		isActive: boolean;

		nextPage(args: object): void;

		previousPage(args: object): void;

	}

	export namespace Scrollbar {
		enum Orientation {
			HORIZONTAL,
			VERTICAL,
		}

		enum VisualStyle {
			DOCKED,
		}

	}

	export class ScrollbarDragListener {
		constructor();

		attach(): void;

		detach(): void;

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

	}

	export namespace ScrollbarDragListener {
	}

	export class SearchItem extends PackageCore.Component {
		constructor(options?: Self.SearchItem.Options);

		activeLink: Self.Link;

		handleKeyPress(): boolean;

		static getRefreshedStyles(theme: PackageCore.RefreshedTheme): void;

		static getRedwoodStyles(theme: PackageCore.RedwoodTheme): void;

	}

	export namespace SearchItem {
		interface Options extends PackageCore.Component.Options {
			link?: Self.SearchItem.LinkItem;

			sublinks?: globalThis.Array<Self.SearchItem.LinkItem>;

			type?: string;

		}

		interface LinkItem {
			description?: string;

			name?: string;

			url?: string;

		}

	}

	enum SearchItemCategory {
		BUTTON,
		COLUMN,
		FIELD,
		FIELD_GROUP,
		LINK,
		MENU,
		SUB_TAB,
		TAB,
		SUBLIST,
	}

	enum SearchItemType {
		ACTION,
		HEADER,
		RESULT,
		MORE,
		FEWER,
		BACK,
		LOADER,
		NO_RESULT,
	}

	export class SelectionCell extends Self.GridCell {
		constructor(options?: object);

		selectable: boolean;

		widgetOptions: (Self.CheckBox.Options | Self.GridCell.WidgetOptionsCallback<Self.CheckBox.Options>);

		singleSelect: boolean;

		setSelectable(value: boolean): void;

	}

	export namespace SelectionCell {
	}

	export class SelectionColumn extends Self.GridColumn {
		constructor(options: Self.SelectionColumn.Options);

		singleSelect: boolean;

		radioGroup: Self.RadioGroup;

		strategy: Self.GridSelectionStrategy;

		selection: Self.GridSelection;

		widgetOptions: (Self.CheckBox.Options | Self.GridColumn.WidgetOptionsCallback<Self.CheckBox.Options> | null);

		setSelection(selection: Self.GridSelection, options?: {forceUpdate?: boolean; reason?: string}): void;

		clearSelection(options?: {reason?: string}): void;

		selectRow(row: Self.GridRow, value: boolean): void;

		selectItem(item: any, value: boolean, options?: {reason?: string}): void;

		selectMulti(mode: Self.GridSelection.Mode, value: boolean, options?: {reason?: string}): void;

		isRowSelected(row: Self.GridDataRow): (boolean | null);

		isRowSelectable(row: Self.GridDataRow): boolean;

		setIsSelectable(callback: (dataItem: any) => boolean): void;

		forceUpdate(): void;

		update(): void;

		static Event: Self.SelectionColumn.EventTypes;

	}

	export namespace SelectionColumn {
		interface Options extends Self.GridColumn.Options {
			singleSelect?: boolean;

			selection?: Self.GridSelection;

			isSelectable?: Self.SelectionColumn.IsSelectableCallback;

			widgetOptions?: (Self.CheckBox.Options | Self.GridColumn.WidgetOptionsCallback<Self.CheckBox.Options>);

			strategy?: Self.GridSelectionStrategy;

			withSelectAll?: boolean;

		}

		type IsSelectableCallback = (dataItem: any) => boolean;

		interface EventTypes extends Self.GridColumn.EventTypes {
			SELECTION_CHANGED: string;

		}

		export import Mode = Self.GridSelection.Mode;

		export import Cell = Self.SelectionCell;

	}

	export class Shell {
		constructor(options?: Self.Shell.Options);

		private layout: Self.Shell.LayoutType;

		theme: PackageCore.Theme;

		supportedThemes: globalThis.Array<PackageCore.Theme.Name>;

		systemHeader: (PackageCore.Component | null);

		applicationHeader: (PackageCore.Component | PackageCore.Presenter | null);

		content: (PackageCore.Presenter | PackageCore.Component | PackageCore.JSX.Element | null);

		topContent: (PackageCore.Component | PackageCore.JSX.Element | null);

		setContent(content: (PackageCore.Presenter | PackageCore.Component | null)): void;

		setTopContent(topContent: (PackageCore.Component | PackageCore.JSX.Element | null)): void;

		setTheme(theme: PackageCore.Theme): void;

		private render(): void;

		run(): void;

		dispose(): void;

	}

	export namespace Shell {
		interface Options {
			host: Self.Host;

			applicationHeader?: (PackageCore.Presenter | PackageCore.Component);

			topCcontent?: (PackageCore.Component | PackageCore.JSX.Element | null);

			content?: (PackageCore.Presenter | PackageCore.Component | PackageCore.JSX.Element);

			router?: PackageCore.Router;

			systemHeader?: PackageCore.Component;

			layout?: Self.Shell.LayoutType;

			supportedThemes?: globalThis.Array<PackageCore.Theme.Name>;

		}

		export import Layout = Self.ShellLayout;

		enum LayoutType {
			NATURAL,
			APPLICATION,
		}

	}

	function ShellLayout(props?: {systemHeader?: (PackageCore.Component | PackageCore.JSX.Element); applicationHeader?: (PackageCore.Component | PackageCore.JSX.Element); topContent?: (PackageCore.VDom.Element | Comment | null); children?: (PackageCore.Component | PackageCore.JSX.Element); appLayout?: boolean}): PackageCore.JSX.Element;

	export class ShuttleUI extends PackageCore.Component {
		constructor(options?: Self.ShuttleUI.Options);

		sourceLabel: string;

		sourceSearch: boolean;

		sourceViewSelected: boolean;

		sourceDataSource: PackageCore.DataSource;

		sourceList: Self.ListBox;

		sourceFilters: (object | null);

		sourceSegments: (object | PackageCore.ArrayDataSource | globalThis.Array<any> | null);

		sourceLoading: boolean;

		sourceSelectedItems: globalThis.Array<any>;

		targetLabel: string;

		targetSearch: boolean;

		targetViewSelected: boolean;

		targetDataSource: PackageCore.DataSource;

		targetList: Self.ListBox;

		targetFilters: (object | null);

		targetSegments: (object | PackageCore.ArrayDataSource | globalThis.Array<any> | null);

		targetLoading: boolean;

		targetSelectedItems: globalThis.Array<any>;

		maxSelection: number;

		dragAndDrop: boolean;

		filters: globalThis.Array<any>;

		segment: globalThis.Array<any>;

		setSourceList(newData?: PackageCore.DataSource, options?: object): void;

		setTargetList(newData?: PackageCore.DataSource, options?: object): void;

		addSelectedItemsToTarget(): void;

		removeSelectedItemsFromTarget(): void;

		addItemToTarget(item: object): void;

		removeItemFromTarget(item: object): void;

		filterSourceList(): void;

		filterTargetList(): void;

		filterLists(): void;

		sourceIsDataGrid(): boolean;

		targetIsDataGrid(): boolean;

		static Event: Self.ShuttleUI.EventTypes;

	}

	export namespace ShuttleUI {
		interface Options extends PackageCore.Component.Options {
			disableFilters?: boolean;

			disableFiltersAndSegments?: boolean;

			disableSegments?: boolean;

			dragAndDrop?: boolean;

			layout?: Self.ShuttleUI.Layout;

			maxSelection?: (number | boolean);

			sourceDataSource?: (PackageCore.DataSource | null);

			sourceDisplayMember?: string;

			sourceFilters?: (object | null);

			sourceLabel?: string;

			sourceSearch?: boolean;

			sourceSegments?: (PackageCore.ArrayDataSource | globalThis.Array<any> | null);

			sourceShowSelectedOnlyCheckbox?: boolean;

			sourceValueMember?: string;

			targetDataSource?: (PackageCore.DataSource | null);

			targetDisplayMember?: string;

			targetFilters?: (object | null);

			targetLabel?: string;

			targetSearch?: boolean;

			targetSegments?: (PackageCore.ArrayDataSource | globalThis.Array<any> | null);

			targetShowSelectedOnlyCheckbox?: boolean;

			targetValueMember?: string;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTION_CHANGED: string;

			SEARCH_CHANGED: string;

			FILTERS_CHANGED: string;

			SEGMENT_CHANGED: string;

		}

		enum I18N {
			TYPE_TO_FILTER,
			NO_ITEMS_TO_SELECT,
			NO_SELECTIONS_MADE,
			BUTTON_ADD_TO_TARGET,
			BUTTON_REMOVE_FROM_TARGET,
			SEGMENTS,
			FILTER,
		}

		enum List {
			SOURCE,
			TARGET,
		}

		enum VisualStyle {
			DEFAULT,
			STANDALONE,
		}

		enum Layout {
			DEFAULT,
			EQUAL_LISTS,
		}

		enum Reason {
			CALL,
		}

	}

	export class ShuttleUIPicker extends Self.Picker {
		constructor(options?: Self.ShuttleUIPicker.Options);

		dataSource: PackageCore.DataSource;

		filter: (dataSource: PackageCore.DataSource, text: string) => PackageCore.DataSource;

		private _handleSelectionChanged(args: {addedItems: globalThis.Array<any>; removedItems: globalThis.Array<any>}, reason: string): void;

		private _forwardKeyDownToShuttle(): void;

	}

	export namespace ShuttleUIPicker {
		interface Options extends Self.Picker.Options {
			dataSource: PackageCore.DataSource;

			filter: (dataSource: PackageCore.DataSource, text: string) => PackageCore.DataSource;

		}

		export import Reason = Self.Picker.Reason;

	}

	export class Skeleton extends PackageCore.Component {
		constructor(options?: Self.Skeleton.Options);

		animation: boolean;

		width: (number | string);

		height: (number | string);

		icon: (Self.Image.Source | null);

		borderRadius: (number | string);

		static rectangle(options?: {width?: (number | string); height?: (number | string)}, settings?: Self.Skeleton.Options): Self.Skeleton;

		static Rectangle(options?: Self.Skeleton.Options): PackageCore.JSX.Element;

		static square(options?: {size?: (number | string)}, settings?: Self.Skeleton.Options): Self.Skeleton;

		static Square(options?: Self.Skeleton.Options & {size?: (number | string)}): PackageCore.JSX.Element;

		static ellipse(options?: {width?: (number | string); height?: (number | string)}, settings?: Self.Skeleton.Options): Self.Skeleton;

		static Ellipse(options?: Self.Skeleton.Options): PackageCore.JSX.Element;

		static circle(options?: {diameter?: (number | string)}, settings?: Self.Skeleton.Options): Self.Skeleton;

		static Circle(options?: Self.Skeleton.Options & {diameter?: (number | string)}): PackageCore.JSX.Element;

		static line(options?: {width?: (number | string); height?: number}, settings?: Self.Skeleton.Options): Self.Skeleton;

		static Line(options?: Self.Skeleton.Options): PackageCore.JSX.Element;

		static lines(options?: {count?: number}, settings?: PackageCore.Component.Options): PackageCore.Component;

		static Lines(options: PackageCore.Component.Options & {count?: number}): PackageCore.JSX.Element;

		static text(options: {count: number}, settings?: PackageCore.Component.Options): PackageCore.Component;

		static Text(props: PackageCore.Component.Options & {count?: number}): PackageCore.JSX.Element;

		static divider(settings?: Self.Skeleton.Options): Self.Skeleton;

		static Divider(props?: Self.Skeleton.Options): PackageCore.JSX.Element;

		static chart(settings?: Self.Skeleton.Options): Self.Skeleton;

		static Chart(props?: Self.Skeleton.Options): PackageCore.JSX.Element;

		static chartBar(settings?: Self.Skeleton.Options): Self.Skeleton;

		static ChartBar(props?: Self.Skeleton.Options): PackageCore.JSX.Element;

		static chartLine(settings?: Self.Skeleton.Options): Self.Skeleton;

		static ChartLine(props?: Self.Skeleton.Options): PackageCore.JSX.Element;

		static table(options?: {rows?: number; columns?: number}, settings?: PackageCore.Component.Options): PackageCore.Component;

		static Table(props?: PackageCore.Component.Options & {rows?: number; columns?: number}): PackageCore.JSX.Element;

		static kpi(options?: Self.ContentPanel.Options): PackageCore.Component;

		static Kpi(props?: PackageCore.Component.Options): PackageCore.JSX.Element;

		static reminder(options?: Self.GridPanel.Options): PackageCore.Component;

		static Reminder(props?: PackageCore.Component.Options): PackageCore.JSX.Element;

		static reminders(options: {count?: number}, settings?: PackageCore.Component.Options): PackageCore.Component;

		static Reminders(props?: PackageCore.Component.Options & {count?: number}): PackageCore.JSX.Element;

		static field(): PackageCore.Component;

		static Field(props?: PackageCore.Component.Options): PackageCore.JSX.Element;

		static fieldGroup(options: {content: PackageCore.Component}): PackageCore.Component;

		static FieldGroup(props?: PackageCore.Component.Options & {children?: any}): PackageCore.JSX.Element;

		static grid(options: {rows: number; columns: number; borderRadius?: (number | string)}, settings: PackageCore.Component.Options): PackageCore.Component;

		static Grid(props: PackageCore.Component.Options & {rows: number; columns: number}): PackageCore.JSX.Element;

		static applicationHeader(options?: {icon?: boolean; subtitle?: boolean; actions?: number}): PackageCore.Component;

		static ApplicationHeader(props?: PackageCore.Component.Options & {icon?: boolean; subtitle?: boolean; actions?: number}): PackageCore.JSX.Element;

	}

	export namespace Skeleton {
		interface Options extends PackageCore.Component.Options {
			animation?: boolean;

			borderRadius?: (number | string);

			height?: (number | string);

			icon?: Self.Image.Source;

			width?: (number | string);

		}

	}

	export class Slider extends PackageCore.Component {
		constructor(options?: Self.Slider.Options);

		selectedItem: (string | number | PackageCore.Translation | Self.Slider.Item);

		bigStep: (number | null);

		editable: boolean;

		readOnly: boolean;

		trackColor: string;

		trackBackgroundCheckerboard: boolean;

		onSelectionChanged: (Self.Slider.SelectionChangedCallback | null);

		selectItem(item: (Self.Slider.Item | string | number | PackageCore.Translation), reason?: string): void;

		selectFirstItem(options?: {reason?: symbol}): void;

		selectNextItem(options?: {reason?: symbol}): void;

		selectPreviousItem(options?: {reason?: symbol}): void;

		selectNextItemWithBigStep(options?: {reason?: symbol}): void;

		selectPreviousItemWithBigStep(options?: object, reason?: symbol): void;

		selectLastItem(options?: {reason?: symbol}): void;

		selectItemOnIndex(index: number, options?: {reason?: symbol}): void;

		selectItemByDistance(distance: number, options?: {reason?: symbol}): void;

		setTrackColor(value: string): void;

		setTrackBackgroundCheckerboard(value: boolean): void;

		private _handleSelectedItemChanged(handle: Self.SliderRange.Handle, item: Self.Slider.Item, previousItem: Self.Slider.Item, reason: (symbol | string)): void;

		private _handleHandleMoved(handle: Self.SliderRange.Handle, position: number, data: Self.SliderRange.HandleData, reason: (symbol | string)): void;

		static Event: Self.Slider.EventTypes;

	}

	export namespace Slider {
		interface Item extends Self.SliderRange.Item {
		}

		interface HandleData extends Self.SliderRange.HandleData {
		}

		interface ValuesObject extends Self.SliderRange.ValuesObject {
		}

		interface Options extends PackageCore.Component.Options {
			selectedItem?: (string | number | Self.Slider.Item);

			trackStart?: (number | string | Self.Slider.Item);

			items?: (object | globalThis.Array<any>);

			labelPosition?: Self.Slider.LabelPosition;

			firstLabelPosition?: Self.Slider.LabelPosition;

			lastLabelPosition?: Self.Slider.LabelPosition;

			firstLabelVisible?: boolean;

			lastLabelVisible?: boolean;

			handleLabelVisible?: boolean;

			edgeLabelAlignment?: Self.Slider.EdgeLabelAlignment;

			orientation?: Self.Slider.Orientation;

			handleDisplayMember?: Self.Slider.DisplayMember;

			labelDisplayMember?: Self.Slider.DisplayMember;

			showSnapLines?: boolean;

			stickyDragging?: boolean;

			trackColor?: (string | PackageCore.Color);

			trackBackgroundCheckerboard?: boolean;

			editable?: boolean;

			readOnly?: boolean;

			bigStep?: number;

			decimalPrecision?: number;

			autoValue?: boolean;

			onSelectionChanged?: Self.Slider.SelectionChangedCallback;

		}

		type SelectionChangedCallback = (args: Self.Slider.SelectionChangedArgs, sender: Self.Slider) => void;

		interface SelectionChangedArgs {
			item: Self.Slider.Item;

			previousItem: Self.Slider.Item;

			reason: (symbol | string);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_ITEM_CHANGED: string;

			HANDLE_MOVED: symbol;

		}

		export import Orientation = Self.SliderRange.Orientation;

		export import LabelPosition = Self.SliderRange.LabelPosition;

		export import EdgeLabelAlignment = Self.SliderRange.EdgeLabelAlignment;

		export import SelectedItemMember = Self.SliderRange.DisplayMember;

		export import DisplayMember = Self.SliderRange.DisplayMember;

		export import DefaultEndItem = Self.SliderRange.DefaultEndItem;

		enum Reason {
			ITEM_SELECTED,
			CALL,
		}

	}

	export class SliderRange extends PackageCore.Component {
		constructor(options?: Self.SliderRange.Options);

		selectedRange: Self.SliderRange.Range;

		selectedRangeStart: Self.SliderRange.Item;

		selectedRangeEnd: Self.SliderRange.Item;

		bigStep: (number | null);

		editable: boolean;

		readOnly: boolean;

		startHandleEnabled: boolean;

		endHandleEnabled: boolean;

		trackColor: string;

		trackBackgroundCheckerboard: boolean;

		onRangeChanged: (Self.SliderRange.RangeChangedCallback | null);

		selectRange(range: (globalThis.Array<Self.SliderRange.Item> | globalThis.Array<string> | globalThis.Array<number> | globalThis.Array<PackageCore.Translation>), options?: {reason?: symbol}): boolean;

		selectRangeItem(item: (Self.SliderRange.Item | string | number | PackageCore.Translation | null), handle: Self.SliderRange.Handle, options?: {reason?: symbol}): boolean;

		selectRangeStart(item: (Self.SliderRange.Item | string | number | PackageCore.Translation | null), options?: {reason?: symbol}): boolean;

		selectRangeEnd(item: (Self.SliderRange.Item | string | number | PackageCore.Translation | null), options?: {reason?: symbol}): boolean;

		selectFirstItem(handle: Self.SliderRange.Handle, options?: {reason?: symbol}): void;

		selectNextItem(handle: Self.SliderRange.Handle, options?: {reason?: symbol}): void;

		selectNextItemWithBigStep(handle: Self.SliderRange.Handle, options?: {reason?: symbol}): void;

		selectPreviousItem(handle: Self.SliderRange.Handle, options?: {reason?: symbol}): void;

		selectPreviousItemWithBigStep(handle: Self.SliderRange.Handle, options?: object, reason?: symbol): void;

		selectLastItem(handle: Self.SliderRange.Handle, options?: {reason?: symbol}): void;

		selectItemOnIndex(index: number, handle: Self.SliderRange.Handle, options?: {reason?: symbol}): void;

		selectItemByDistance(distance: number, handle: Self.SliderRange.Handle, options?: {reason?: symbol}): void;

		setTrackColor(value: (string | PackageCore.Color)): void;

		setTrackBackgroundCheckerboard(value: boolean): void;

		enableHandle(handle: Self.SliderRange.Handle, value: boolean): void;

		private _createGridFractions(labelCount: number): globalThis.Array<string>;

		private _createGridElement(items: globalThis.Array<PackageCore.JSX.Element>, gridFractions: globalThis.Array<string>): Self.GridPanel;

		private _createHandlesLabelsAsGridItems(gridFractionsCount: number): void;

		private _createTrackAsGridItem(gridFractionsCount: number): void;

		private _createItemsAsGridItems(gridFractionsCount: number): void;

		private _createEdgeLabelGridItem(label: PackageCore.Component, fractionsCount: number, position: Self.SliderRange.LabelPosition, edgeLabel: Self.SliderRange.EdgeLabel): void;

		private _createLabelGridItem(label: PackageCore.Component, index: number, fractionsCount: number): void;

		private _createLabelComponent(labelValue: (number | string | PackageCore.Translation | PackageCore.ImageMetadata | PackageCore.Component), firstOrLast?: Self.SliderRange.EdgeLabel, position?: Self.SliderRange.LabelPosition): PackageCore.Component;

		private _createHandleLabelContainer(handle: Self.SliderRange.Handle): PackageCore.Component;

		private _createMixedHandleLabelContainer(): PackageCore.JSX.Element;

		private _createHandleLabel(handle: (Self.SliderRange.Handle | null), mixed?: boolean): PackageCore.Component;

		private _parseItems(items: (Self.SliderRange.ValuesObject | globalThis.Array<string> | globalThis.Array<number> | globalThis.Array<object>)): globalThis.Array<Self.SliderRange.Item>;

		private _handleSelectedRangeChanged(previousRange: globalThis.Array<Self.SliderRange.Item>, range: globalThis.Array<Self.SliderRange.Item>, reason: (string | symbol)): void;

		private _handleSelectedItemChanged(handle: Self.SliderRange.Handle, previousItem: Self.SliderRange.Item, item: Self.SliderRange.Item, reason: (string | symbol)): void;

		private _handleHandleMoved(handle: Self.SliderRange.Handle, position: number, reason: (string | symbol)): void;

		private _handleClick(message: object, result: object): void;

		private _handleMove(message: object): void;

		private _handleRelease(): void;

		private _setMixedHandleLabelVisibility(): void;

		private _initLastMovedHandle(): void;

		private _getEdgeLabelMainAxisIndex(edgeLabel: Self.SliderRange.EdgeLabel, rowPosition: Self.SliderRange.LabelPosition, fractionsCount: number): number;

		private _getLabelCrossAxisIndex(labelPosition: Self.SliderRange.LabelPosition): number;

		private _getEdgeLabelMainAxisAlignment(edgeLabel: Self.SliderRange.EdgeLabel): Self.GridPanel.Justification;

		private _getEdgeLabelCrossAxisAlignment(position: Self.SliderRange.LabelPosition): Self.GridPanel.Alignment;

		private _getEdgeLabelMainAxisCellSpan(position: Self.SliderRange.LabelPosition): number;

		private _getHandleClosestItem(mousePosition: object): Self.SliderRange.Item;

		private _getClosestHandle(position: number): (Self.SliderRange.Handle | null);

		private _getMouseTrackPosition(message: object, isFrameworkMessage?: boolean): number;

		private _getBoundedMouseTrackPosition(handleInMotion: Self.SliderRange.Handle, oppositeHandleData: Self.SliderRange.HandleData, mousePosition: number): number;

		private _getItem(item: (string | number | PackageCore.Translation | Self.SliderRange.Item | null)): (Self.SliderRange.Item | null);

		private _getItemByDistance(handle: Self.SliderRange.Handle, distance?: number): Self.SliderRange.Item;

		private _getItemByIndex(handle: Self.SliderRange.Handle, index: number): Self.SliderRange.Item;

		private _getBoundedItemIndex(handle: Self.SliderRange.Handle, index: number): number;

		private _getLongestLabelLength(): void;

		private _getDefaultLabelPosition(): Self.SliderRange.LabelPosition;

		private _isHorizontal(): boolean;

		private _isHorizontalLtr(): boolean;

		private _isHorizontalRtl(): boolean;

		private _isVertical(): boolean;

		private _initDirection(): string;

		static Event: Self.SliderRange.EventTypes;

	}

	export namespace SliderRange {
		type Range = [Self.SliderRange.Item, Self.SliderRange.Item];

		interface Item {
			index: number;

			value: number;

			label: (string | number | PackageCore.Translation | PackageCore.ImageMetadata | PackageCore.Component);

			labelDisabled: boolean;

			position: number;

			ariaValueText: (string | number | PackageCore.Translation);

		}

		interface HandleData {
			element: HTMLElement;

			label: PackageCore.Component;

			item: Self.SliderRange.Item;

			closestItem: Self.SliderRange.Item;

			currentPosition: number;

			enabled: boolean;

		}

		interface ValuesObject {
			start: number;

			end: number;

			startRoot?: number;

			step?: number;

			labelStep?: number;

			labels?: (globalThis.Array<number> | globalThis.Array<string> | globalThis.Array<PackageCore.Translation> | globalThis.Array<PackageCore.ImageMetadata> | globalThis.Array<PackageCore.Component>);

			firstLabel?: (number | string | PackageCore.Translation | PackageCore.ImageMetadata | PackageCore.Component | null);

			lastLabel?: (number | string | PackageCore.Translation | PackageCore.ImageMetadata | PackageCore.Component | null);

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			selectedRange?: globalThis.Array<(string | number | Self.SliderRange.Item)>;

			items?: (Self.SliderRange.ValuesObject | globalThis.Array<any>);

			labelPosition?: Self.SliderRange.LabelPosition;

			firstLabelPosition?: Self.SliderRange.LabelPosition;

			lastLabelPosition?: Self.SliderRange.LabelPosition;

			firstLabelVisible?: boolean;

			lastLabelVisible?: boolean;

			handleLabelVisible?: boolean;

			edgeLabelAlignment?: Self.SliderRange.EdgeLabelAlignment;

			orientation?: Self.SliderRange.Orientation;

			handleDisplayMember?: Self.SliderRange.DisplayMember;

			labelDisplayMember?: Self.SliderRange.DisplayMember;

			startHandleEnabled?: boolean;

			endHandleEnabled?: boolean;

			startHandlePresent?: boolean;

			endHandlePresent?: boolean;

			showSnapLines?: boolean;

			stickyDragging?: boolean;

			trackColor?: (string | PackageCore.Color);

			trackBackgroundCheckerboard?: boolean;

			editable?: boolean;

			readOnly?: boolean;

			bigStep?: number;

			decimalPrecision?: number;

			autoValue?: boolean;

			onRangeChanged?: Self.SliderRange.RangeChangedCallback;

		}

		type RangeChangedCallback = (args: Self.SliderRange.RangeChangedArgs, sender: Self.SliderRange) => void;

		interface RangeChangedArgs {
			range: Self.SliderRange.Range;

			previousRange: Self.SliderRange.Range;

			reason: (string | symbol);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_ITEM_CHANGED: string;

			SELECTED_RANGE_CHANGED: string;

			HANDLE_MOVED: string;

		}

		export import Orientation = Self.SliderRangeEnums.Orientation;

		enum Handle {
			START,
			END,
		}

		enum LabelPosition {
			BOTTOM,
			TOP,
			TRACK_ALIGNED,
		}

		enum EdgeLabelAlignment {
			DEFAULT,
			TRACK_END,
		}

		enum EdgeLabel {
			FIRST,
			LAST,
		}

		enum DisplayMember {
			LABEL,
			VALUE,
		}

		enum DefaultEndItem {
			LAST,
			FIRST,
		}

		enum Reason {
			ITEM_SELECTED,
			CALL,
			HANDLE_MOVED,
		}

	}

	export class SliderRangeControlHandler implements PackageCore.MessageHandler {
		constructor(options?: object);

		attach(): void;

		detach(): void;

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

	}

	export namespace SliderRangeControlHandler {
	}

	export namespace SliderRangeEnums {
		enum Orientation {
			VERTICAL,
			HORIZONTAL,
		}

	}

	class SliderRangeHandle extends PackageCore.Component {
		constructor(options?: Self.SliderRangeHandle.Options);

	}

	namespace SliderRangeHandle {
		interface Options extends PackageCore.Component.Options {
			description: string;

			pressed: boolean;

			readOnly: boolean;

		}

	}

	class SliderRangeTrack extends PackageCore.Component {
		constructor(options?: Self.SliderRangeTrack.Options);

		private _isHorizontalLtr(): boolean;

		private _isHorizontalRtl(): boolean;

		private _createSnaplineElements(): PackageCore.JSX.Element;

		private _createBaseElement(): PackageCore.JSX.Element;

		private _createFillElement(): PackageCore.JSX.Element;

	}

	namespace SliderRangeTrack {
		interface Options extends PackageCore.Component.Options {
			color: (PackageCore.Color | string);

			endHandle: Self.SliderRangeHandle;

			startHandle: Self.SliderRangeHandle;

			snapLinesCount: number;

			snapLinesVisible: boolean;

			orientation: Self.SliderRangeTrack.Orientation;

			checkerBoard: boolean;

		}

		export import Orientation = Self.SliderRangeEnums.Orientation;

	}

	export class SplitButton extends PackageCore.Component {
		constructor(options?: Self.SplitButton.Options);

		action: Self.Button.ActionCallback;

		label: (null | string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		hasLabel: boolean;

		icon: (PackageCore.ImageMetadata | null);

		hasIcon: boolean;

		iconPosition: Self.SplitButton.IconPosition;

		size: Self.SplitButton.Size;

		type: Self.SplitButton.Type;

		hierarchy: Self.SplitButton.Hierarchy;

		menuOpened: boolean;

		menu: (globalThis.Array<Self.MenuItem.ItemDefinition> | Self.Menu.Options);

		openOnHover: boolean;

		toggled: boolean;

		bloom: boolean;

		setLabel(label: (null | string | number | PackageCore.Translation | PackageCore.Component)): void;

		setIcon(icon: (PackageCore.ImageMetadata | null)): void;

		setIconPosition(position: Self.SplitButton.IconPosition): void;

		setSize(size: Self.SplitButton.Size): void;

		setType(type: Self.SplitButton.Type): void;

		setHierarchy(hierarchy: Self.SplitButton.Hierarchy): void;

		setMenu(menu: (globalThis.Array<Self.MenuItem.ItemDefinition> | Self.Menu.Options)): void;

		openMenu(args?: object): void;

		closeMenu(args?: object): void;

		click(): void;

		static Event: Self.SplitButton.EventTypes;

	}

	export namespace SplitButton {
		interface Options extends PackageCore.Component.Options {
			action?: Self.Button.ActionCallback;

			hierarchy?: Self.SplitButton.Hierarchy;

			icon?: Self.Image.Source;

			iconPosition?: Self.SplitButton.IconPosition;

			label?: (null | string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			menu: (globalThis.Array<Self.MenuItem.ItemDefinition> | Self.Menu.Options);

			size?: Self.SplitButton.Size;

			type?: Self.SplitButton.Type;

			bloom?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ACTION: string;

			MENU_OPENED: string;

			MENU_CLOSED: string;

		}

		export import Size = Self.Button.Size;

		export import IconPosition = Self.Button.IconPosition;

		export import Type = Self.Button.Type;

		export import Hierarchy = Self.Button.Hierarchy;

		export import VisualStyle = Self.Button.VisualStyle;

	}

	export class SplitPanel extends PackageCore.Component {
		constructor(options?: Self.SplitPanel.Options);

		items: globalThis.Array<Self.SplitPanelItem>;

		children: PackageCore.VDom.Children;

		components: globalThis.Array<PackageCore.Component>;

		orientation: Self.SplitPanel.Orientation;

		length: number;

		empty: boolean;

		decorator: (PackageCore.Decorator | null);

		add(component: Self.SplitPanel.ItemConfiguration): Self.SplitPanel;

		remove(component: (PackageCore.Component | number)): Self.SplitPanel;

		clear(): Self.SplitPanel;

		setOrientation(orientation: Self.SplitPanel.Orientation): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		itemForComponent(component: PackageCore.Component): Self.SplitPanelItem;

		indexForComponent(component: PackageCore.Component): (number | null);

		static Horizontal(props: Self.SplitPanel.Options): PackageCore.JSX.Element;

		static Vertical(props: Self.SplitPanel.Options): PackageCore.JSX.Element;

		static Item(props?: Self.SplitPanel.JsxItemProps): PackageCore.JSX.Element;

		static Event: Self.SplitPanel.EventTypes;

	}

	export namespace SplitPanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items?: globalThis.Array<Self.SplitPanel.ItemConfiguration>;

			orientation?: Self.SplitPanel.Orientation;

			decorator?: PackageCore.Decorator;

			element?: Self.SplitPanel.Element;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ADDED: string;

			ITEM_REMOVED: string;

			ITEM_RESIZE_STARTED: string;

			ITEM_RESIZE_FINISHED: string;

			ITEM_RESIZED: string;

		}

		interface BaseItemProps {
			value?: any;

			collapse?: Self.SplitPanel.ItemCollapse;

			handleStyle?: Self.SplitPanel.HandleStyle;

			maxSize?: (string | number);

			minSize?: (string | number);

			resizable?: boolean;

			size?: (Self.SplitPanelItem.SizeOptions | string | number);

		}

		interface ItemProps extends Self.SplitPanel.BaseItemProps {
		}

		interface JsxItemProps extends Self.SplitPanel.BaseItemProps {
			children?: PackageCore.VDom.Children;

			key?: any;

		}

		interface StructuredItemConfiguration {
			component: PackageCore.Component;

			options?: Self.SplitPanel.ItemProps;

		}

		interface FlatItemConfiguration extends Self.SplitPanel.ItemProps {
			component: PackageCore.Component;

		}

		type ItemConfiguration = (PackageCore.Component | Self.SplitPanel.StructuredItemConfiguration | Self.SplitPanel.FlatItemConfiguration);

		export import Orientation = Self.SplitPanelItem.Orientation;

		export import ItemSize = Self.SplitPanelItemSize;

		export import HandleStyle = Self.SplitPanelItem.HandleStyle;

		export import ItemCollapse = Self.SplitPanelItem.Collapse;

		export import Element = PackageCore.Html.Element.Section;

	}

	export class SplitPanelItem extends PackageCore.Component {
		constructor(options?: Self.SplitPanelItem.Options);

		component: PackageCore.Component;

		children: PackageCore.VDom.Children;

		value: any;

		size: (Self.SplitPanelItem.SizeOptions | string | number);

		minSize: (string | number);

		maxSize: (string | number);

		handleStyle: Self.SplitPanel.HandleStyle;

		collapse: Self.SplitPanel.ItemCollapse;

		collapsed: boolean;

		resizable: boolean;

		effectiveResizable: boolean;

		setCollapsed(value: boolean): void;

		static Event: Self.SplitPanelItem.EventTypes;

	}

	export namespace SplitPanelItem {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			collapse?: Self.SplitPanel.ItemCollapse;

			component: PackageCore.Component;

			value?: any;

			handleStyle?: Self.SplitPanel.HandleStyle;

			maxSize?: (string | number);

			minSize?: (string | number);

			resizable?: boolean;

			size?: (Self.SplitPanelItem.SizeOptions | string | number);

		}

		interface SizeOptions {
			grow: number;

			shrink: number;

			basis: (number | string);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			RESIZE_STARTED: string;

			RESIZE_UPDATE: string;

			RESIZE_FINISHED: string;

		}

		enum Orientation {
			HORIZONTAL,
			VERTICAL,
		}

		export import Size = Self.SplitPanelItemSize;

		enum HandleStyle {
			GRAB_BEFORE,
			GRAB_AFTER,
			STRIP,
			TRANSPARENT,
		}

		enum Collapse {
			NONE,
			START,
			END,
		}

	}

	export namespace SplitPanelItemSize {
		const AUTO_SIZE: Self.SplitPanelItem.SizeOptions;

		function INITIAL_SIZE(size: (number | string)): Self.SplitPanelItem.SizeOptions;

		function FRACTION_SIZE(factor: number): Self.SplitPanelItem.SizeOptions;

		const CONTENT_SIZE: Self.SplitPanelItem.SizeOptions;

	}

	export class StackPanel extends PackageCore.Component {
		constructor(options?: Self.StackPanel.Options);

		items: globalThis.Array<Self.StackPanelItem>;

		components: globalThis.Array<PackageCore.Component>;

		children: PackageCore.VDom.Children;

		length: number;

		empty: boolean;

		orientation: Self.StackPanel.Orientation;

		wrap: (boolean | Self.StackPanel.Wrap);

		justification: Self.StackPanel.Justification;

		alignment: Self.StackPanel.Alignment;

		wrappedContentAlignment: Self.StackPanel.WrappedContentAlignment;

		outerGap: (Self.StackPanel.GapSize | Self.StackPanel.GapSizeObject);

		itemGap: Self.StackPanel.GapSize;

		wrapGap: Self.StackPanel.GapSize;

		decorator: (PackageCore.Decorator | null);

		element: Self.StackPanel.Element;

		defaultItemOptions: Self.StackPanel.ItemProps;

		add(components: (Self.StackPanel.ItemConfiguration | globalThis.Array<Self.StackPanel.ItemConfiguration>)): Self.StackPanel;

		remove(componentOrIndex: (PackageCore.Component | number | globalThis.Array<(PackageCore.Component | number)>)): Self.StackPanel;

		move(args: {component: (PackageCore.Component | number); index: number; reason?: string}): Self.StackPanel;

		clear(): Self.StackPanel;

		replace(currentComponentOrIndex: (PackageCore.Component | number), newComponent: PackageCore.Component): void;

		has(component: PackageCore.Component): boolean;

		itemAtIndex(index: number): Self.StackPanelItem;

		itemForComponent(component: PackageCore.Component): Self.StackPanelItem;

		indexForComponent(component: PackageCore.Component): (number | null);

		setOrientation(value: Self.StackPanel.Orientation): void;

		setWrap(value: (boolean | Self.StackPanel.Wrap)): void;

		setJustification(value: Self.StackPanel.Justification): void;

		setAlignment(value: Self.StackPanel.Alignment): void;

		setWrappedContentAlignment(value: Self.StackPanel.WrappedContentAlignment): void;

		setOuterGap(value: Self.StackPanel.GapSize): void;

		setItemGap(value: Self.StackPanel.GapSize): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		static horizontal(items?: (object | globalThis.Array<PackageCore.Component> | globalThis.Array<Self.StackPanelItem.Options>)): Self.StackPanel;

		static Horizontal(props: Self.StackPanel.Options): PackageCore.JSX.Element;

		static HorizontalReverse(props: Self.StackPanel.Options): PackageCore.JSX.Element;

		static vertical(items?: (object | globalThis.Array<PackageCore.Component> | globalThis.Array<Self.StackPanelItem.Options>)): Self.StackPanel;

		static Vertical(props: Self.StackPanel.Options): PackageCore.JSX.Element;

		static VerticalReverse(props: Self.StackPanel.Options): PackageCore.JSX.Element;

		static horizontalSplit(start: Self.StackPanel.ItemConfiguration, end: Self.StackPanel.ItemConfiguration, options?: Self.StackPanel.Options): void;

		static HorizontalSplit(props: Self.StackPanel.Options): PackageCore.JSX.Element;

		static verticalSplit(start: Self.StackPanel.ItemConfiguration, end: Self.StackPanel.ItemConfiguration, options?: Self.StackPanel.Options): void;

		static VerticalSplit(props: Self.StackPanel.Options): PackageCore.JSX.Element;

		static getStyles(): void;

		static Event: Self.StackPanel.EventTypes;

		static Item(props?: Self.StackPanel.JsxItemProps): PackageCore.JSX.Element;

	}

	export namespace StackPanel {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			alignment?: Self.StackPanel.Alignment;

			decorator?: PackageCore.Decorator;

			defaultItemOptions?: Self.StackPanel.ItemProps;

			itemGap?: Self.StackPanel.GapSize;

			wrapGap?: Self.StackPanel.GapSize;

			items?: (Self.StackPanel.ItemConfiguration | globalThis.Array<Self.StackPanel.ItemConfiguration>);

			justification?: Self.StackPanel.Justification;

			orientation?: Self.StackPanel.Orientation;

			outerGap?: (Self.StackPanel.GapSize | Self.StackPanel.GapSizeObject);

			wrap?: (Self.StackPanel.Wrap | boolean);

			element?: Self.StackPanel.Element;

			wrappedContentAlignment?: Self.StackPanel.WrappedContentAlignment;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ADDED: string;

			ITEM_REMOVED: string;

			ITEM_MOVED: string;

		}

		interface BaseItemProps {
			grow?: number;

			shrink?: number;

			basis?: string;

			selfAlignment?: Self.StackPanelItem.SelfAlignment;

		}

		interface ItemProps extends Self.StackPanel.BaseItemProps {
			index?: number;

		}

		interface JsxItemProps extends Self.StackPanel.BaseItemProps {
			children?: PackageCore.VDom.Children;

			key?: any;

		}

		interface StructuredItemConfiguration {
			component: PackageCore.Component;

			options?: Self.StackPanel.ItemProps;

		}

		interface FlatItemConfiguration extends Self.StackPanel.ItemProps {
			component: PackageCore.Component;

		}

		interface GapSizeObject {
			top?: Self.StackPanel.GapSize;

			bottom?: Self.StackPanel.GapSize;

			start?: Self.StackPanel.GapSize;

			end?: Self.StackPanel.GapSize;

			horizontal?: Self.StackPanel.GapSize;

			vertical?: Self.StackPanel.GapSize;

		}

		type ItemConfiguration = (PackageCore.Component | Self.StackPanel.StructuredItemConfiguration | Self.StackPanel.FlatItemConfiguration);

		enum Orientation {
			HORIZONTAL,
			HORIZONTAL_REVERSE,
			VERTICAL,
			VERTICAL_REVERSE,
		}

		enum Justification {
			START,
			END,
			CENTER,
			SPACE_AROUND,
			SPACE_BETWEEN,
			SPACE_EVENLY,
		}

		enum Alignment {
			NORMAL,
			START,
			END,
			CENTER,
			STRETCH,
			BASELINE,
		}

		enum Wrap {
			NO_WRAP,
			WRAP,
			WRAP_REVERSE,
		}

		export import Element = PackageCore.Html.Element.Section;

		export import SelfAlignment = Self.StackPanelItem.SelfAlignment;

		enum WrappedContentAlignment {
			START,
			END,
			CENTER,
			STRETCH,
			SPACE_AROUND,
			SPACE_BETWEEN,
		}

		export import GapSize = Self.GapSize;

		enum VisualStyle {
			BLOCK,
			INLINE,
			PLAIN,
		}

		export import ItemOptions = Self.StackPanelItemLayout;

		export import Decorator = PackageCore.Decorator;

	}

	export class StackPanelItem {
		constructor(options?: Self.StackPanelItem.Options);

		component: PackageCore.Component;

		selfAlignment: Self.StackPanelItem.SelfAlignment;

		grow: number;

		shrink: number;

		basis: string;

		index: number;

		setSelfAlignment(value: Self.StackPanelItem.SelfAlignment): void;

		setGrow(value: number): void;

		setShrink(value: number): void;

		setBasis(value: string): void;

	}

	export namespace StackPanelItem {
		interface Options {
			component: PackageCore.Component;

			grow?: number;

			shrink?: number;

			basis?: string;

			selfAlignment?: Self.StackPanelItem.SelfAlignment;

			index?: number;

		}

		enum SelfAlignment {
			START,
			END,
			CENTER,
			STRETCH,
			AUTO,
		}

	}

	namespace StackPanelItemLayout {
		const FILL_SPACE: Self.StackPanel.ItemProps;

		const EQUAL_SIZE: Self.StackPanel.ItemProps;

		const KEEP_SIZE: Self.StackPanel.ItemProps;

		function FRACTION_SIZE(fraction: number): Self.StackPanel.ItemProps;

	}

	namespace StandardWindow {
	}

	class StaticListView extends PackageCore.Component {
		constructor();

		stickyGroupHeaders: boolean;

		groupAutomationIdMember: (string | null);

		scrollTo(item: object): void;

		static Event: Self.StaticListView.EventTypes;

	}

	namespace StaticListView {
		interface EventTypes extends PackageCore.Component.EventTypes {
			SCROLL_TO_END: string;

		}

	}

	class StaticTreeContainer extends PackageCore.Component {
		constructor();

	}

	namespace StaticTreeContainer {
	}

	export class Stepper extends PackageCore.Component {
		constructor(options?: Self.Stepper.Options);

		children: PackageCore.VDom.Children;

		items: globalThis.Array<object>;

		selectedStepIndex: (number | null);

		orientation: Self.Stepper.Orientation;

		descriptionPosition: Self.Stepper.DescriptionPosition;

		separatorSize: Self.Stepper.SeparatorSize;

		labelGenerator: (index: number, options: object) => (string | number | PackageCore.Translation | PackageCore.JSX.Element | PackageCore.Component);

		descriptionGenerator: (index: number, options: object) => (string | number | PackageCore.Translation | PackageCore.JSX.Element | PackageCore.Component);

		defaultItemOptions: object;

		onSelectionChanged: (Self.Stepper.SelectionChangedCallback | null);

		setItems(items: globalThis.Array<object>): void;

		setSelectedStepIndex(index: number, reason: (string | symbol)): void;

		static Horizontal(props: Self.Stepper.Options): PackageCore.JSX.Element;

		static Vertical(props: Self.Stepper.Options): PackageCore.JSX.Element;

		static Event: Self.Stepper.EventTypes;

		static defaultLabelGenerator(index: number, props: object): (PackageCore.JSX.Element | string);

		static defaultDescriptionGenerator(index: number, props: object): PackageCore.Translation;

	}

	export namespace Stepper {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			orientation?: Self.Stepper.Orientation;

			descriptionPosition?: Self.Stepper.DescriptionPosition;

			separatorSize?: Self.Stepper.SeparatorSize;

			selectedStepIndex: (number | null);

			labelGenerator?: (index: number, options: object) => ((number | string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element));

			descriptionGenerator?: (index: number, options: object) => ((number | string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element));

			defaultItemOptions?: object;

			onSelectionChanged?: Self.Stepper.SelectionChangedCallback;

		}

		type SelectionChangedCallback = (args: Self.Stepper.SelectionChangedArgs, sender: Self.Stepper) => void;

		interface SelectionChangedArgs {
			stepIndex: number;

			previousStepIndex: number;

			reason: Self.Stepper.Reason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED_STEP_INDEX_CHANGED: symbol;

			STEP_ACTIVATED: string;

			STEP_DEACTIVATED: string;

		}

		export import Item = Self.StepperItem;

		export import Orientation = Self.StepperItem.Orientation;

		export import DescriptionPosition = Self.StepperItem.DescriptionPosition;

		export import SeparatorSize = Self.StepperItem.SeparatorSize;

		export import ItemType = Self.StepperItem.Type;

		enum Reason {
			CALL,
		}

		enum I18N {
			STEP,
		}

	}

	export class StepperItem extends PackageCore.Component {
		constructor(options?: Self.StepperItem.Options);

		label: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		description: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		children: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		orientation: Self.StepperItem.Orientation;

		descriptionPosition: Self.StepperItem.DescriptionPosition;

		descriptionMaxWidth: number;

		separatorSize: Self.StepperItem.SeparatorSize;

		type: Self.StepperItem.Type;

		separatorStart: boolean;

		separatorEnd: boolean;

		selected: boolean;

		optional: boolean;

		onActivate: (item: Self.StepperItem, index: number) => boolean;

		onDeactivate: (item: Self.StepperItem, index: number) => boolean;

		index: number;

		static Event: Self.StepperItem.EventTypes;

	}

	export namespace StepperItem {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			label?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			orientation?: Self.StepperItem.Orientation;

			descriptionPosition?: Self.StepperItem.DescriptionPosition;

			descriptionMaxWidth?: number;

			separatorSize?: Self.StepperItem.SeparatorSize;

			type?: Self.StepperItem.Type;

			separatorStart?: boolean;

			separatorEnd?: boolean;

			selected?: boolean;

			optional?: boolean;

			onActivate?: (item: Self.StepperItem, index: number) => boolean;

			onDeactivate?: (item: Self.StepperItem, index: number) => boolean;

			index: number;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			STEP_ACTIVATED: symbol;

			STEP_DEACTIVATED: symbol;

		}

		enum Reason {
			CALL,
			ENTER,
			CLICK,
		}

		enum Orientation {
			VERTICAL,
			HORIZONTAL,
		}

		enum DescriptionPosition {
			TOP,
			BOTTOM,
			START,
			END,
		}

		enum Type {
			DEFAULT,
			NEUTRAL,
			PRIMARY,
			INFO,
			SUCCESS,
			WARNING,
			ERROR,
		}

		enum SeparatorSize {
			NONE,
			XS,
			S,
			M,
			L,
			XL,
			STRETCH,
		}

	}

	export namespace Studio {
		interface Project {
			components: object;

		}

		function Component(props: {project: Self.Studio.Project; component: string; bundles?: globalThis.Array<any>}): (props?: object) => PackageCore.Component;

	}

	export class SummaryBox extends PackageCore.Component {
		constructor(options?: Self.SummaryBox.Options);

		title: (string | number | PackageCore.Translation);

		collapsed: boolean;

		collapsible: boolean;

		currency: (string | number | PackageCore.Translation | null);

		children: PackageCore.VDom.Children;

		items: globalThis.Array<Self.SummaryBox.ItemOptions>;

		private parseChildren(children: PackageCore.VDom.Children): globalThis.Array<Self.SummaryBox.ItemOptions>;

		static Item(props?: Self.SummaryBoxItem.Options): PackageCore.JSX.Element;

		static Total(props?: Self.SummaryBoxTotal.Options): PackageCore.JSX.Element;

	}

	export namespace SummaryBox {
		interface ItemOptions {
			label: (string | number | PackageCore.Translation);

			color?: Self.SummaryBoxItem.Color;

			icon?: Self.Image.Source;

			value: (string | number | PackageCore.Translation);

			type: Self.SummaryBox.Type;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items?: globalThis.Array<Self.SummaryBox.ItemOptions>;

			collapsed?: boolean;

			collapsible?: boolean;

			currency?: (string | number | PackageCore.Translation);

			title: (string | number | PackageCore.Translation);

		}

		export import Color = Self.SummaryBoxItem.Color;

		enum Type {
			ITEM,
			TOTAL,
		}

	}

	export function SummaryBoxItem(options?: Self.SummaryBoxItem.Options): void;

	export namespace SummaryBoxItem {
		interface Options {
			label: (string | number | PackageCore.Translation);

			color?: Self.SummaryBoxItem.Color;

			icon?: Self.Image.Source;

			value: (string | number | PackageCore.Translation);

		}

		enum Color {
			NEUTRAL,
			INFO,
			SUCCESS,
			WARNING,
			ERROR,
		}

	}

	export function SummaryBoxTotal(options?: Self.SummaryBoxTotal.Options): void;

	export namespace SummaryBoxTotal {
		interface Options {
			label: (string | number | PackageCore.Translation);

			value: (string | number | PackageCore.Translation);

		}

	}

	export class Switch extends PackageCore.Component {
		constructor(options?: Self.Switch.Options);

		value: boolean;

		iconOn: PackageCore.ImageMetadata;

		iconOff: PackageCore.ImageMetadata;

		readOnly: boolean;

		action: (Self.Switch.ActionCallback | null);

		label: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element | null);

		labelPosition: Self.Switch.LabelPosition;

		clickableLabel: boolean;

		emptyLabel: boolean;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		size: Self.Switch.Size;

		setValue(value: boolean, options?: {reason?: (string | symbol)}): void;

		toggle(options?: object): void;

		static Event: Self.Switch.EventTypes;

	}

	export namespace Switch {
		interface Options extends PackageCore.Component.Options {
			iconOff?: PackageCore.ImageMetadata;

			iconOn?: PackageCore.ImageMetadata;

			readOnly?: boolean;

			value?: boolean;

			action?: Self.Switch.ActionCallback;

			clickableLabel?: boolean;

			label?: (string | number | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			labelPosition?: Self.Switch.LabelPosition;

			size?: Self.Switch.Size;

		}

		type ActionCallback = (args: Self.Switch.ActionArgs, sender: Self.Switch) => void;

		interface ActionArgs {
			value: boolean;

			previousValue: boolean;

			reason: string;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TOGGLED: string;

		}

		enum Reason {
			SETTER,
			CLICK,
			KEY_PRESS,
		}

		enum LabelPosition {
			LEFT,
			RIGHT,
			ABOVE,
			BELOW,
		}

		enum Size {
			M,
			S,
		}

		enum VisualStyle {
			STANDALONE,
		}

	}

	class SystemHeader extends PackageCore.Component {
		constructor(options?: Self.SystemHeader.Options);

		logos: globalThis.Array<PackageCore.JSX.Element>;

		withSeparator: boolean;

		environment: Self.SystemHeader.Environment;

	}

	namespace SystemHeader {
		interface Options extends PackageCore.Component.Options {
			logos?: globalThis.Array<PackageCore.JSX.Element>;

			withSeparator?: boolean;

			environment?: Self.SystemHeader.Environment;

		}

		enum Environment {
			PRODUCTION,
			RELEASE_PREVIEW,
			SANDBOX,
			F,
			SNAP,
			DEBUGGER,
		}

	}

	class SystemSearch {
		addPageSearchItem(item: Self.PageSearch.SearchableItem, options: Self.PageSearch.SearchableItemOptions): void;

		addPageSearchItems(items: globalThis.Array<Self.PageSearch.SearchableItem>, options: Self.PageSearch.SearchableItemOptions): void;

		removePageSearchItem(itemId: string): void;

	}

	namespace SystemSearch {
		interface Options {
			searchTermValidator?: () => boolean;

			showResultsDelay?: number;

			globalSearch?: object;

			pageSearch?: object;

			shortcut?: globalThis.Array<globalThis.Array<string>>;

		}

	}

	export class Tab extends PackageCore.Component {
		constructor(options?: Self.Tab.Options);

		label: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		labelEditor: (Self.InlineEditor | null);

		allowLabelEditing: boolean;

		icon: object;

		contextControls: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

		actionControls: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

		value: any;

		selected: boolean;

		defaultSelected: boolean;

		closable: boolean;

		accessKey: string;

		accessShortcut: PackageCore.KeyShortcut;

		contentId: string;

		editorOptions: Self.InlineEditor.Options;

		dropBefore: boolean;

		dropAfter: boolean;

		setLabel(label: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element), reason?: string): void;

		setIcon(icon: (PackageCore.ImageMetadata | null)): void;

		setSelected(selected: boolean, reason?: any): void;

		setAccessKey(key: string): void;

		setClosable(closable: boolean): void;

		static Event: Self.Tab.EventTypes;

	}

	export namespace Tab {
		interface Options extends PackageCore.Component.Options {
			value?: any;

			icon?: Self.Image.Source;

			label: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			contextControls?: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

			actionControls?: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

			selected?: boolean;

			defaultSelected?: boolean;

			closable?: boolean;

			accessKey?: string;

			allowLabelEditing?: boolean;

			editorOptions?: Self.InlineEditor.Options;

			hierarchy?: Self.Tab.Hierarchy;

			position?: Self.Tab.Position;

			stripePosition?: Self.Tab.StripePosition;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			LABEL_CHANGED: string;

			LABEL_EDITING_STARTED: string;

			LABEL_EDITING_FINISHED: string;

			SELECTED: string;

			CLOSE: string;

		}

		export import VisualStyle = Self.TabPanelOptions.VisualStyle;

		export import Hierarchy = Self.TabPanelOptions.Hierarchy;

		export import Position = Self.TabPanelOptions.TabPosition;

		export import StripePosition = Self.TabPanelOptions.TabStripePosition;

		export import Reason = Self.TabPanelOptions.Reason;

	}

	class TabListDragSource {
		constructor();

	}

	namespace TabListDragSource {
	}

	class TabListDragTarget {
		constructor(tabList: (Self.ScrollTabList));

	}

	namespace TabListDragTarget {
	}

	export class TabPanel extends PackageCore.Component {
		constructor(options?: Self.TabPanel.Options);

		items: globalThis.Array<Self.TabPanelItem>;

		components: globalThis.Array<PackageCore.Component>;

		element: Self.TabPanel.Element;

		children: PackageCore.VDom.Children;

		length: number;

		empty: boolean;

		tabPosition: Self.TabPanel.TabPosition;

		tabStripePosition: Self.TabPanel.TabStripePosition;

		tabJustification: Self.TabPanel.TabPosition;

		tabReorder: boolean;

		hierarchy: Self.TabPanel.Hierarchy;

		divider: boolean;

		selectedValue: any;

		selectedComponent: PackageCore.Component;

		selectedItem: (Self.TabPanelItem | null);

		selectedIndex: number;

		outerGap: (Self.TabPanel.GapSize | Self.TabPanel.GapSizeObject);

		tabsGap: (Self.TabPanel.GapSize | Self.TabPanel.GapSizeObject);

		contentGap: (Self.TabPanel.GapSize | Self.TabPanel.GapSizeObject);

		tabSpacer: (boolean | null);

		decorator: (PackageCore.Decorator | null);

		tabsDecorator: (PackageCore.Decorator | null);

		defaultItemOptions: Self.TabPanel.ItemProps;

		setSelectedValue(value: any, args?: {reason?: string}): void;

		add(component: (Self.TabPanel.ItemConfiguration | globalThis.Array<Self.TabPanel.ItemConfiguration>)): Self.TabPanel;

		remove(componentOrIndex: (PackageCore.Component | number | globalThis.Array<(PackageCore.Component | number)>)): Self.TabPanel;

		move(args: {component: (PackageCore.Component | number); index: number; reason?: string}): Self.TabPanel;

		clear(): Self.TabPanel;

		replace(currentComponent: (PackageCore.Component | number), newComponent: PackageCore.Component): Self.TabPanel;

		has(component: PackageCore.Component): boolean;

		itemForComponent(component: PackageCore.Component): (Self.TabPanelItem | null);

		itemAtIndex(index: number): (Self.TabPanelItem | null);

		select(component: (PackageCore.Component | number), reason?: string): void;

		isSelected(component: PackageCore.Component): boolean;

		selectFirst(reason?: string): void;

		selectLast(reason?: string): void;

		selectNext(reason?: string): void;

		selectPrevious(reason?: string): void;

		setOuterGap(value: Self.TabPanel.GapSize): void;

		setTabsGap(value: Self.TabPanel.GapSize): void;

		setContentGap(value: Self.TabPanel.GapSize): void;

		setTabSpacer(value: boolean): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

		setTabsDecorator(decorator: (PackageCore.Decorator | null)): void;

		getTab(component: PackageCore.Component): (Self.Tab | null);

		static TabLabelUpdater(args: object): void;

		static Item(props: Self.TabPanel.JsxItemProps): PackageCore.JSX.Element;

		static Event: Self.TabPanel.EventTypes;

	}

	export namespace TabPanel {
		interface BaseItemProps {
			value?: any;

			icon?: Self.Image.Source;

			label?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			contextControls?: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

			actionControls?: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)>);

			closable?: boolean;

			accessKey?: string;

			allowLabelEditing?: boolean;

			editorOptions?: Self.InlineEditor.Options;

			automationId?: string;

		}

		interface ItemProps extends Self.TabPanel.BaseItemProps {
			selected?: boolean;

		}

		interface JsxItemProps extends Self.TabPanel.BaseItemProps {
			children?: PackageCore.VDom.Children;

			key?: any;

			ref?: PackageCore.VDomRef;

		}

		interface GapSizeObject {
			top?: Self.TabPanel.GapSize;

			bottom?: Self.TabPanel.GapSize;

			start?: Self.TabPanel.GapSize;

			end?: Self.TabPanel.GapSize;

			horizontal?: Self.TabPanel.GapSize;

			vertical?: Self.TabPanel.GapSize;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			hierarchy?: Self.TabPanel.Hierarchy;

			items?: (Self.TabPanel.ItemConfiguration | globalThis.Array<Self.TabPanel.ItemConfiguration>);

			selectedValue?: any;

			onBeforeTabClose?: (tab: Self.Tab) => boolean;

			tabJustification?: Self.TabPanel.TabJustification;

			tabPosition?: Self.TabPanel.TabPosition;

			tabStripePosition?: Self.TabPanel.TabStripePosition;

			tabReorder?: boolean;

			outerGap?: (Self.TabPanel.GapSize | Self.TabPanel.GapSizeObject);

			tabsGap?: (Self.TabPanel.GapSize | Self.TabPanel.GapSizeObject);

			contentGap?: (Self.TabPanel.GapSize | Self.TabPanel.GapSizeObject);

			tabSpacer?: boolean;

			divider?: boolean;

			defaultItemOptions?: Self.TabPanel.ItemProps;

			tabListOptions?: Self.ScrollTabList.Options;

			decorator?: PackageCore.Decorator;

			tabsDecorator?: PackageCore.Decorator;

			element?: Self.TabPanel.Element;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ADDED: string;

			ITEM_REMOVED: string;

			ITEM_MOVED: string;

			ITEM_SELECTED: string;

			TAB_SELECTED: string;

			TAB_CLOSED: string;

			TAB_REORDER: string;

			TAB_LABEL_EDITING_STARTED: string;

			TAB_LABEL_EDITING_FINISHED: string;

			TAB_LABEL_CHANGED: string;

		}

		interface StructuredItemConfiguration {
			component: PackageCore.Component;

			options?: Self.TabPanel.ItemProps;

		}

		interface FlatItemConfiguration extends Self.TabPanel.ItemProps {
			component: PackageCore.Component;

		}

		type ItemConfiguration = (PackageCore.Component | Self.TabPanel.StructuredItemConfiguration | Self.TabPanel.FlatItemConfiguration);

		export import TabPosition = Self.TabPanelOptions.TabPosition;

		export import TabStripePosition = Self.TabPanelOptions.TabStripePosition;

		export import TabJustification = Self.TabPanelOptions.TabJustification;

		export import TabOverflow = Self.TabPanelOptions.TabOverflow;

		export import Hierarchy = Self.TabPanelOptions.Hierarchy;

		export import GapSize = Self.GapSize;

		export import Decorator = PackageCore.Decorator;

		export import VisualStyle = Self.TabPanelOptions.VisualStyle;

		enum ContentUpdateReason {
			ITEM_ADDED,
			ITEM_REMOVED,
			ITEM_MOVED,
			ITEM_SELECTED,
			SELECTED_VALUE_CHANGED,
			TAB_LIST_POSITION_CHANGED,
		}

		export import Reason = Self.TabPanelOptions.Reason;

		export import Element = PackageCore.Html.Element.Section;

	}

	export class TabPanelItem {
		constructor(options: Self.TabPanelItem.Options);

		component: PackageCore.Component;

		tab: Self.Tab;

		selected: boolean;

		closable: boolean;

		icon: Self.Image.Source;

		label: (string | PackageCore.Translation);

		contextControls: globalThis.Array<PackageCore.Component>;

		actionControls: globalThis.Array<PackageCore.Component>;

		accessShortcut: PackageCore.KeyShortcut;

		setSelected(value: boolean): void;

		setClosable(value: boolean): void;

		setIcon(icon: Self.Image.Source, reason: string): void;

		setLabel(label: (string | PackageCore.Translation)): void;

	}

	export namespace TabPanelItem {
		interface Options extends PackageCore.Component.Options {
			component: PackageCore.Component;

			tab: Self.Tab;

		}

	}

	namespace TabPanelOptions {
		enum Hierarchy {
			PRIMARY,
			SECONDARY,
		}

		enum TabPosition {
			TOP,
			BOTTOM,
			LEFT,
			RIGHT,
		}

		enum TabStripePosition {
			START,
			END,
		}

		enum TabJustification {
			START,
			STRETCH,
			END,
		}

		enum TabOverflow {
			SCROLL,
			POPUP,
		}

		enum VisualStyle {
			STANDALONE,
			LEGACY,
		}

		enum Reason {
			CALL,
			CLICK,
			ACCESS_KEY,
			KEY_DOWN,
			ITEM_ADDED,
			ITEM_REMOVED,
			DRAG,
			LABEL_SYNC,
		}

	}

	export class Table extends PackageCore.Component {
		constructor(options?: Self.Table.Options);

		children: PackageCore.VDom.Children;

		caption: (string | null);

		header: (globalThis.Array<any> | null);

		body: globalThis.Array<globalThis.Array<any>>;

		footer: (globalThis.Array<any> | null);

		private renderTableCaption(): PackageCore.JSX.Element;

		private renderTableHeader(): PackageCore.JSX.Element;

		private renderTableBody(): PackageCore.JSX.Element;

		private renderTableFooter(): PackageCore.JSX.Element;

		private renderCell(cellOptions: (string | number | PackageCore.Translation | PackageCore.Component | object), cellType: symbol): PackageCore.JSX.Element;

		private renderTable(): globalThis.Array<PackageCore.JSX.Element>;

		private normalizeContent(content: any): globalThis.Array<(PackageCore.Component | string)>;

		static Header(args: {classList?: (string | globalThis.Array<string> | PackageCore.Style | globalThis.Array<PackageCore.Style>); rootStyle?: object; rootAttributes?: object; children?: PackageCore.VDom.Children; key?: any}): PackageCore.JSX.Element;

		static Body(args: {classList?: (string | globalThis.Array<string> | PackageCore.Style | globalThis.Array<PackageCore.Style>); rootStyle?: object; rootAttributes?: object; children?: PackageCore.VDom.Children; key?: any}): PackageCore.JSX.Element;

		static Footer(args: {classList?: (string | globalThis.Array<string> | PackageCore.Style | globalThis.Array<PackageCore.Style>); rootStyle?: object; rootAttributes?: object; children?: PackageCore.VDom.Children; key?: any}): PackageCore.JSX.Element;

		static Row(args: {classList?: (string | globalThis.Array<string> | PackageCore.Style | globalThis.Array<PackageCore.Style>); rootStyle?: object; rootAttributes?: object; children?: PackageCore.VDom.Children; key?: any}): PackageCore.JSX.Element;

		static HeaderCell(args: {classList?: (string | globalThis.Array<string> | PackageCore.Style | globalThis.Array<PackageCore.Style>); rootStyle?: object; rootAttributes?: object; children?: PackageCore.VDom.Children; key?: any}): PackageCore.JSX.Element;

		static Cell(args: {classList?: (string | globalThis.Array<string> | PackageCore.Style | globalThis.Array<PackageCore.Style>); rootStyle?: object; rootAttributes?: object; children?: PackageCore.VDom.Children; key?: any}): PackageCore.JSX.Element;

		static Caption(args: {classList?: (string | globalThis.Array<string> | PackageCore.Style | globalThis.Array<PackageCore.Style>); rootStyle?: object; rootAttributes?: object; children?: PackageCore.VDom.Children; key?: any}): PackageCore.JSX.Element;

	}

	export namespace Table {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			body?: (globalThis.Array<globalThis.Array<any>> | null);

			caption?: (string | Self.Text | null);

			footer?: (globalThis.Array<any> | null);

			header?: (globalThis.Array<any> | null);

		}

	}

	export class TemplatedCell extends Self.GridCell {
		constructor(options: Self.TemplatedCell.Options);

	}

	export namespace TemplatedCell {
		interface Options extends Self.GridCell.Options {
		}

	}

	export class TemplatedColumn extends Self.GridColumn {
		constructor(options?: Self.TemplatedColumn.Options);

		content: (Self.TemplatedColumn.ContentCallback | null);

		copyValueProvider: (Self.TemplatedColumn.CopyValueProvider | null);

	}

	export namespace TemplatedColumn {
		interface Options extends Self.GridColumn.Options {
			content: Self.TemplatedColumn.ContentCallback;

			copyValueProvider?: Self.TemplatedColumn.CopyValueProvider;

		}

		type ContentCallback = (args: Self.TemplatedColumn.ContentArgs) => (PackageCore.Component | PackageCore.JSX.Element);

		interface ContentArgs {
			cell: Self.TemplatedCell;

			context: any;

		}

		type CopyValueProvider = (cell: Self.TemplatedCell) => (string | Element);

		export import Cell = Self.TemplatedCell;

	}

	export class Text extends PackageCore.Component {
		constructor(options?: (Self.Text.Options | string | number | PackageCore.Translation));

		text: (string | number | PackageCore.Translation);

		children: PackageCore.VDom.Children;

		type: Self.Text.Type;

		size: (Self.Text.Size | null);

		weight: (Self.Text.Weight | null);

		color: (Self.Text.Color | null);

		fontStyle: (Self.Text.FontStyle | null);

		decoration: (Self.Text.Decoration | null);

		decorator: (PackageCore.Decorator | null);

		wrap: (boolean | number);

		whitespace: boolean;

		ellipsisHelper: Self.EllipsisTooltip;

		setText(text: (string | number | PackageCore.Translation)): void;

		setType(type: Self.Text.Type): void;

		setWrap(value: (boolean | number)): void;

		setWhitespace(value: boolean): void;

		setDecorator(decorator: (PackageCore.Decorator | null)): void;

	}

	export namespace Text {
		interface KeyboardOptions {
			inverse?: boolean;

		}

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			decorator?: PackageCore.Decorator;

			text?: (string | number | PackageCore.Translation);

			type?: Self.Text.Type;

			color?: Self.Text.Color;

			size?: Self.Text.Size;

			weight?: Self.Text.Weight;

			fontStyle?: Self.Text.FontStyle;

			decoration?: Self.Text.Decoration;

			whitespace?: boolean;

			wrap?: (boolean | number);

		}

		enum Size {
			XXS,
			XS,
			S,
			M,
			L,
			XL,
			XXL,
			XXXL,
		}

		enum Weight {
			NORMAL,
			SEMI_BOLD,
			BOLD,
		}

		enum Color {
			PRIMARY,
			SECONDARY,
			PLACEHOLDER,
		}

		enum Type {
			DEFAULT,
			STRONG,
			WEAK,
		}

		enum FontStyle {
			NORMAL,
			ITALIC,
		}

		enum Decoration {
			NONE,
			UNDERLINE,
		}

	}

	export class TextArea extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.TextArea.Options);

		text: string;

		defaultText: (string | number);

		name: string;

		acceptedText: string;

		formattedText: string;

		placeholder: (string | PackageCore.Translation);

		maxLength: number;

		maxLengthIndicator: boolean;

		empty: boolean;

		mandatory: boolean;

		selection: Self.TextArea.Selection;

		caretPosition: number;

		hasMaxLength: boolean;

		autoComplete: (Self.TextArea.AutoComplete | string);

		textAlignment: Self.TextArea.TextAlignment;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		rowCount: number;

		columnCount: number;

		resizable: boolean;

		formatter: (Self.TextArea.FormatterCallback | null);

		textValidator: (Self.TextArea.TextValidatorCallback | null);

		keyValidator: (Self.TextArea.KeyValidatorCallback | null);

		size: Self.TextArea.Size;

		onTextChanged: (Self.TextArea.TextChangedCallback | null);

		onTextAccepted: (Self.TextArea.TextAcceptedCallback | null);

		bloom: boolean;

		setText(text: (string | number), options?: {reason?: string; accept?: boolean}): boolean;

		setName(name: string): void;

		setSelection(options: {start: number; end: number; direction?: Self.TextArea.SelectionDirection; reason?: string}): boolean;

		setCaretPosition(position: number): void;

		setMaxLength(maxLength: number): boolean;

		setMaxLengthIndicator(value: boolean): void;

		setMandatory(mandatory: boolean): void;

		setPlaceholder(placeholder: (string | PackageCore.Translation)): void;

		setRowCount(rowCount: number): void;

		setColumnCount(columnCount: number): void;

		setTextAlignment(alignment: Self.TextArea.TextAlignment): void;

		setAutoComplete(value: string): void;

		setResizable(resizable: boolean): void;

		selectAll(): void;

		acceptChanges(options: {reason?: string}): void;

		static Event: Self.TextArea.EventTypes;

	}

	export namespace TextArea {
		interface Options extends PackageCore.Component.Options {
			acceptInvalidValue?: boolean;

			autoComplete?: string;

			columnCount?: number;

			formatter?: Self.TextArea.FormatterCallback;

			keyValidator?: Self.TextArea.KeyValidatorCallback;

			maxLength?: number;

			maxLengthIndicator?: boolean;

			placeholder?: (string | PackageCore.Translation);

			resizable?: boolean;

			resizeDirection?: Self.TextArea.ResizeDirection;

			rowCount?: number;

			text?: (string | number);

			defaultText?: (string | number);

			textAlignment?: Self.TextArea.TextAlignment;

			textValidator?: Self.TextArea.TextValidatorCallback;

			mandatory?: boolean;

			size?: Self.TextArea.Size;

			onTextChanged?: Self.TextArea.TextChangedCallback;

			onTextAccepted?: Self.TextArea.TextAcceptedCallback;

			contentToolbar?: (PackageCore.Component | PackageCore.JSX.Element);

			bloom?: boolean;

		}

		type TextChangedCallback = (args: Self.TextArea.TextChangedArgs, sender: Self.TextArea) => void;

		interface TextChangedArgs {
			text: string;

			previousText: string;

			reason: Self.TextArea.TextChangeReason;

		}

		type TextAcceptedCallback = (args: Self.TextArea.TextAcceptedArgs, sender: Self.TextArea) => void;

		interface TextAcceptedArgs {
			text: string;

			previousText: string;

			reason: Self.TextArea.TextAcceptedReason;

		}

		type TextValidatorCallback = (args: {text: string}) => boolean;

		type KeyValidatorCallback = (args: {keyCode: number; charCode: number; char: string; text: string; selection: Self.TextArea.Selection}) => boolean;

		interface Selection {
			start: number;

			end: number;

			direction?: Self.TextArea.SelectionDirection;

			text?: string;

		}

		type FormatterCallback = (args: {text: string; valid: boolean}) => string;

		interface EventTypes extends PackageCore.Component.EventTypes {
			TEXT_CHANGED: string;

			TEXT_ACCEPTED: string;

			SELECTION_CHANGED: string;

			CARET_POSITION_CHANGED: string;

			AREA_RESIZED: string;

		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
			REDWOOD_FIELD,
		}

		enum AutoComplete {
			ON,
			OFF,
		}

		enum TextAlignment {
			LEFT,
			RIGHT,
			CENTER,
		}

		enum TextChangeReason {
			INPUT,
			MAX_LENGTH,
		}

		enum TextAcceptedReason {
			FOCUS_OUT,
			ENTER,
			CALL,
		}

		enum SelectionChangeReason {
			SELECT_ALL,
			TEXT_CHANGED,
			REFRESH,
		}

		enum ResizeDirection {
			BOTH,
			HORIZONTAL,
			VERTICAL,
		}

		export import SelectionDirection = Self.TextSelection.Direction;

		export import Size = Self.InputSize;

	}

	export class TextAreaCell extends Self.GridCell {
		constructor();

		resizableEditor: boolean;

		popupEdit: boolean;

		popupHeight: number;

		formatter: (((args: {cell: Self.TextAreaCell; text: string}) => string) | null);

		wrap: boolean;

		overlayGuid: string;

		textArea: (Self.TextArea | null);

		widgetOptions: (Self.TextArea.Options | Self.GridCell.WidgetOptionsCallback<Self.TextArea.Options>);

	}

	export namespace TextAreaCell {
	}

	export class TextAreaColumn extends Self.GridColumn {
		constructor(options?: Self.TextAreaColumn.Options);

		resizableEditor: boolean;

		popupEdit: boolean;

		popupHeight: number;

		formatter: (Self.TextAreaColumn.FormatterCallback | null);

		wrap: boolean;

		widgetOptions: (Self.TextArea.Options | Self.GridColumn.WidgetOptionsCallback<Self.TextArea.Options> | null);

	}

	export namespace TextAreaColumn {
		interface Options extends Self.GridColumn.Options {
			resizableEditor?: boolean;

			popupEdit?: boolean;

			popupHeight?: number;

			formatter?: Self.TextAreaColumn.FormatterCallback;

			wrap?: boolean;

			widgetOptions?: (Self.TextArea.Options | Self.GridColumn.WidgetOptionsCallback<Self.TextArea.Options>);

		}

		type FormatterCallback = (args: Self.TextAreaColumn.FormatterArgs) => string;

		interface FormatterArgs {
			cell: Self.TextAreaCell;

			text: string;

		}

		export import Cell = Self.TextAreaCell;

	}

	export class TextBox extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.TextBox.Options);

		text: string;

		defaultText: (string | number);

		name: string;

		acceptedText: string;

		formattedText: string;

		placeholder: (string | PackageCore.Translation);

		maxLength: number;

		maxLengthIndicator: boolean;

		empty: boolean;

		mandatory: boolean;

		selection: Self.TextBox.Selection;

		caretPosition: number;

		hasMaxLength: boolean;

		autoComplete: (Self.TextBox.AutoComplete | string);

		textAlignment: Self.TextBox.TextAlignment;

		clearButton: boolean;

		inputSize: number;

		type: Self.TextBox.Type;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		formatter: (Self.TextBox.FormatterCallback | null);

		textValidator: (Self.TextBox.TextValidatorCallback | null);

		icon: (PackageCore.ImageMetadata | PackageCore.Component | PackageCore.JSX.Element | null);

		iconAlignment: Self.TextBox.IconAlignment;

		iconAction: (((args: object) => void) | null);

		keyValidator: (Self.TextBox.KeyValidatorCallback | null);

		overflowTooltip: boolean;

		spinner: (number | object | null);

		confirm: (Self.TextBox.ConfirmCallback | null);

		size: Self.TextBox.Size;

		overflowsHorizontally: (boolean | null);

		onTextChanged: (Self.TextBox.TextChangedCallback | null);

		onTextAccepted: (Self.TextBox.TextAcceptedCallback | null);

		setText(text: (string | number), options?: {reason?: string; accept?: boolean}): boolean;

		setName(name: string): void;

		clear(reason?: string): void;

		setSelection(options: {start: number; end: number; direction?: Self.TextBox.SelectionDirection; reason?: string}): boolean;

		setCaretPosition(position: number): void;

		setMaxLength(maxLength: number): void;

		setMaxLengthIndicator(value: boolean): void;

		setMandatory(mandatory: boolean): void;

		setPlaceholder(placeholder: (string | PackageCore.Translation)): void;

		setInputSize(size: number): void;

		setTextAlignment(alignment: Self.TextBox.TextAlignment): void;

		setType(type: Self.TextBox.Type): void;

		setAutoComplete(value: (string | Self.TextBox.AutoComplete)): void;

		setClearButton(value: boolean): void;

		setConfirm(confirm: (Self.TextBox.ConfirmCallback | null)): void;

		setSpinner(spinner: (number | object | null)): void;

		selectAll(): boolean;

		acceptChanges(options: {reason?: string}): void;

		setIconAlignment(value: Self.TextBox.IconAlignment): void;

		setIcon(value: (PackageCore.ImageMetadata | PackageCore.Component | HTMLElement)): void;

		static createSearchBox(options: Self.TextBox.Options): Self.TextBox;

		static Search(props: Self.TextBox.Options): PackageCore.JSX.Element;

		static createLoginBox(options: Self.TextBox.Options): Self.TextBox;

		static Login(props: Self.TextBox.Options): PackageCore.JSX.Element;

		static createPasswordBox(options: Self.TextBox.Options): Self.TextBox;

		static Password(props: Self.TextBox.Options): PackageCore.JSX.Element;

		static Event: Self.TextBox.EventTypes;

	}

	export namespace TextBox {
		interface Options extends PackageCore.Component.Options {
			acceptInvalidValue?: boolean;

			autoComplete?: string;

			ariaLabel?: string;

			clearButton?: boolean;

			formatter?: Self.TextBox.FormatterCallback;

			icon?: (PackageCore.ImageMetadata | PackageCore.Component | PackageCore.JSX.Element);

			iconAction?: (args: object) => void;

			iconAlignment?: Self.TextBox.IconAlignment;

			inputSize?: number;

			inputAttributes?: object;

			keyValidator?: Self.TextBox.KeyValidatorCallback;

			maxLength?: number;

			maxLengthIndicator?: boolean;

			mandatory?: boolean;

			name?: string;

			overflowTooltip?: boolean;

			placeholder?: (string | PackageCore.Translation);

			text?: (string | number);

			defaultText?: (string | number);

			textAlignment?: Self.TextBox.TextAlignment;

			textValidator?: Self.TextBox.TextValidatorCallback;

			confirm?: Self.TextBox.ConfirmCallback;

			type?: Self.TextBox.Type;

			spinner?: (number | object);

			size?: Self.TextBox.Size;

			onTextChanged?: Self.TextBox.TextChangedCallback;

			onTextAccepted?: Self.TextBox.TextAcceptedCallback;

		}

		type TextChangedCallback = (args: Self.TextBox.TextChangedArgs, sender: Self.TextBox) => void;

		interface TextChangedArgs {
			text: string;

			previousText: string;

			reason: Self.TextBox.TextChangeReason;

		}

		type TextAcceptedCallback = (args: Self.TextBox.TextAcceptedArgs, sender: Self.TextBox) => void;

		interface TextAcceptedArgs {
			text: string;

			previousText: string;

			reason: Self.TextBox.TextAcceptedReason;

		}

		type TextValidatorCallback = (args: {text: string}) => boolean;

		type KeyValidatorCallback = (args: {keyCode: number; charCode: number; char: string; text: string; selection: Self.TextBox.Selection}) => boolean;

		type FormatterCallback = (args: {text: string; valid: boolean}) => string;

		type ConfirmCallback = (args: {text: string}) => boolean;

		interface Selection {
			start: number;

			end: number;

			direction?: Self.TextBox.SelectionDirection;

			text?: string;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			TEXT_CHANGED: string;

			TEXT_ACCEPTED: string;

			SELECTION_CHANGED: string;

			CARET_POSITION_CHANGED: string;

		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
			SYSTEM_HEADER,
			REDWOOD_FIELD,
		}

		enum Reason {
			CLEAR,
		}

		enum AutoComplete {
			ON,
			OFF,
		}

		enum TextAlignment {
			LEFT,
			RIGHT,
			CENTER,
		}

		enum TextChangeReason {
			INPUT,
			MAX_LENGTH,
		}

		enum TextAcceptedReason {
			FOCUS_OUT,
			ENTER,
			CALL,
		}

		enum SelectionChangeReason {
			SELECT_ALL,
			TEXT_CHANGED,
			REFRESH,
		}

		enum IconAlignment {
			START,
			END,
		}

		enum Type {
			TEXT,
			NUMBER,
			PASSWORD,
			FILE,
			EMAIL,
			URL,
		}

		export import SelectionDirection = Self.TextSelection.Direction;

		export import Size = Self.InputSize;

	}

	export class TextBoxCell extends Self.GridCell {
		constructor();

		textAlignment: Self.TextBox.TextAlignment;

		inputType: Self.TextBox.Type;

		formatter: (((args: {cell: Self.TextAreaCell; text: string}) => string) | null);

		wrap: boolean;

		textBox: (Self.TextBox | null);

		widgetOptions: (Self.TextBox.Options | Self.GridCell.WidgetOptionsCallback<Self.TextBox.Options>);

	}

	export namespace TextBoxCell {
	}

	export class TextBoxColumn extends Self.GridColumn {
		constructor(options?: Self.TextBoxColumn.Options);

		textAlignment: Self.TextBox.TextAlignment;

		inputType: Self.TextBox.Type;

		formatter: (Self.TextBoxColumn.FormatterCallback | null);

		wrap: boolean;

		widgetOptions: (Self.TextBox.Options | Self.GridColumn.WidgetOptionsCallback<Self.TextBox.Options> | null);

	}

	export namespace TextBoxColumn {
		interface Options extends Self.GridColumn.Options {
			textAlignment?: Self.TextBox.TextAlignment;

			inputType?: Self.TextBox.Type;

			formatter?: Self.TextBoxColumn.FormatterCallback;

			wrap?: boolean;

			widgetOptions?: (Self.TextBox.Options | Self.GridColumn.WidgetOptionsCallback<Self.TextBox.Options>);

		}

		type FormatterCallback = (args: Self.TextBoxColumn.FormatterArgs) => string;

		interface FormatterArgs {
			cell: Self.TextBoxCell;

			text: string;

		}

		export import Cell = Self.TextBoxCell;

	}

	export class TextBoxPicker extends Self.Picker {
		constructor(options?: Self.TextBoxPicker.Options);

	}

	export namespace TextBoxPicker {
		interface Options extends PackageCore.Component.Options {
			textBoxOptions: Self.TextBox.Options;

		}

	}

	class TextSelection {
		constructor(start: number, end: number, direction?: Self.TextSelection.Direction, text?: string);

	}

	namespace TextSelection {
		enum Direction {
			FORWARD,
			BACKWARD,
		}

	}

	namespace TextStyle {
		function styles(css: object, wrap: (boolean | number), whitespace: boolean): globalThis.Array<PackageCore.Style>;

	}

	export function ThemeRoot(props: {theme: PackageCore.Theme; children?: PackageCore.VDom.Children}): PackageCore.JSX.Element;

	function ThemeRootContent(props: {children?: PackageCore.VDom.Children}): PackageCore.JSX.Element;

	export function ThemeSelector(props: {supportedThemes?: globalThis.Array<PackageCore.Theme.Name>; children?: PackageCore.VDom.Children}): PackageCore.JSX.Element;

	export class TimePicker extends PackageCore.Component implements PackageCore.InputComponent {
		constructor(options?: Self.TimePicker.Options);

		time: (PackageCore.Time | null);

		empty: boolean;

		mandatory: boolean;

		format: (string | null);

		formatter: (Self.TimePicker.FormatterCallback | null);

		parser: (Self.TimePicker.ParserCallback | null);

		startTime: (PackageCore.Time | null);

		endTime: (PackageCore.Time | null);

		inputText: string;

		inputId: string;

		inputAttributes: PackageCore.HtmlAttributeList;

		allowUserInput: boolean;

		timePickerOpened: boolean;

		iconPosition: Self.TimePicker.IconPosition;

		placeholder: (string | null);

		size: Self.TimePicker.Size;

		onTimeChanged: (Self.TimePicker.TimeChangedCallback | null);

		acceptChanges(): void;

		setTime(time: (PackageCore.Time | null), options?: {reason?: string; updateInputText?: string}): void;

		setInputText(text: string, options?: {reason?: string; acceptChanges?: boolean}): void;

		setFormat(format: string): void;

		setFormatter(formatter: (((time: (PackageCore.Time | null)) => string) | null)): void;

		setParser(parser: (((text: string) => (PackageCore.Time | null)) | null)): void;

		setStartTime(time: (PackageCore.Time | null)): void;

		setEndTime(time: (PackageCore.Time | null)): void;

		openTimePicker(): boolean;

		closeTimePicker(): boolean;

		toggleTimePicker(): void;

		selectAll(): void;

		static Event: Self.TimePicker.EventTypes;

	}

	export namespace TimePicker {
		interface Options extends PackageCore.Component.Options {
			allowEmptyValue?: boolean;

			validator?: Self.TimePicker.ValidatorCallback;

			endTime?: PackageCore.Time;

			format?: string;

			formatter?: Self.TimePicker.FormatterCallback;

			iconPosition?: Self.TimePicker.IconPosition;

			parser?: Self.TimePicker.ParserCallback;

			placeholder?: string;

			startTime?: PackageCore.Time;

			time?: PackageCore.Time;

			timeline?: object;

			mandatory?: boolean;

			allowUserInput?: boolean;

			picker?: object;

			size?: Self.TimePicker.Size;

			onTimeChanged?: Self.TimePicker.TimeChangedCallback;

		}

		type TimeChangedCallback = (args: Self.TimePicker.TimeChangedArgs, sender: Self.TimePicker) => void;

		interface TimeChangedArgs {
			time: (PackageCore.Time | null);

			previousTime: (PackageCore.Time | null);

			reason: Self.TimePicker.Reason;

		}

		type ValidatorCallback = (args: {empty: boolean; inputText: string; time: (PackageCore.Time | null)}) => void;

		type FormatterCallback = (time: (PackageCore.Time | null)) => string;

		type ParserCallback = (text: string) => (PackageCore.Time | null);

		interface EventTypes extends PackageCore.Component.EventTypes {
			TIME_CHANGED: string;

			INPUT_TEXT_CHANGED: string;

			INPUT_TEXT_ACCEPTED: string;

		}

		enum IconPosition {
			START,
			END,
		}

		enum Reason {
			AFTER,
			BEFORE,
			CLEAR,
			EMPTY,
			ENTER,
			INVALID_INPUT,
			PICKER_SELECTION_CHANGED,
			TEXT_CHANGED,
			TIME_CHANGED,
			TIME_FORMATTED,
		}

		export import Size = Self.InputSize;

	}

	export class TimePickerCell extends Self.GridCell {
		constructor();

		format: string;

		formatter: (time: (PackageCore.Time | null)) => string;

		parser: (text: string) => (PackageCore.Time | null);

		timePicker: (Self.TimePicker | null);

		bindToText: boolean;

		widgetOptions: (Self.TimePicker.Options | Self.GridCell.WidgetOptionsCallback<Self.TimePicker.Options>);

	}

	export namespace TimePickerCell {
	}

	export class TimePickerColumn extends Self.GridColumn {
		constructor(options?: Self.TimePickerColumn.Options);

		format: (string | null);

		formatter: (Self.TimePicker.FormatterCallback | null);

		parser: (Self.TimePicker.ParserCallback | null);

		bindToText: boolean;

		widgetOptions: (Self.TimePicker.Options | Self.GridColumn.WidgetOptionsCallback<Self.TimePicker.Options> | null);

		static defaultComparator(cell: Self.TimePickerCell, oldValue: (PackageCore.Time | string), newValue: (PackageCore.Time | string)): boolean;

	}

	export namespace TimePickerColumn {
		interface Options extends Self.GridColumn.Options {
			format?: string;

			formatter?: Self.TimePicker.FormatterCallback;

			parser?: Self.TimePicker.ParserCallback;

			bindToText?: boolean;

			widgetOptions?: (Self.TimePicker.Options | Self.GridColumn.WidgetOptionsCallback<Self.TimePicker.Options>);

		}

		export import Cell = Self.TimePickerCell;

	}

	export class TimeRange extends PackageCore.Component {
		constructor(options?: Self.TimeRange.Options);

		start: (Self.TimePicker | null);

		startRef: PackageCore.VDomRef;

		end: (Self.TimePicker | null);

		endRef: PackageCore.VDomRef;

		range: Self.TimeRange.Range;

		rangeStart: (PackageCore.Time | null);

		rangeEnd: (PackageCore.Time | null);

		inputOptions: Self.TimePicker.Options;

		startOptions: Self.TimePicker.Options;

		endOptions: Self.TimePicker.Options;

		onRangeChanged: (Self.TimeRange.RangeChangedCallback | null);

		setRange(value: Self.TimeRange.Range, options?: {reason?: string}): void;

		setRangeStart(startTime: (PackageCore.Time | null), options?: {reason?: string}): void;

		setRangeEnd(endTime: (PackageCore.Time | null), options?: {reason?: string}): void;

		static rangeEquals(left: (Self.TimeRange.Range | null), right: (Self.TimeRange.Range | null)): boolean;

		static Event: Self.TimeRange.EventTypes;

	}

	export namespace TimeRange {
		interface Options extends PackageCore.Component.Options {
			defaultInterval?: (((time: PackageCore.Time) => PackageCore.Time) | null);

			endOptions?: Self.TimePicker.Options;

			inputOptions?: Self.TimePicker.Options;

			range?: Self.TimeRange.Range;

			startOptions?: Self.TimePicker.Options;

			startRef?: PackageCore.VDomRef;

			endRef?: PackageCore.VDomRef;

			onRangeChanged?: Self.TimeRange.RangeChangedCallback;

		}

		interface Range {
			startTime: (PackageCore.Time | null);

			endTime: (PackageCore.Time | null);

		}

		type RangeChangedCallback = (args: Self.TimeRange.RangeChangedArgs, sender: Self.TimeRange) => void;

		interface RangeChangedArgs {
			range: (Self.TimeRange.Range | null);

			previousRange: (Self.TimeRange.Range | null);

			reason: Self.TimeRange.Reason;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			RANGE_CHANGED: string;

		}

		enum I18N {
			TO,
		}

		enum Reason {
			TIME_CHANGED,
			INTERVAL,
		}

		enum VisualStyle {
			DEFAULT,
			REDWOOD_FIELD,
		}

	}

	export class TimeRangePicker extends Self.Picker {
		constructor(options: Self.TimeRangePicker.Options);

		private _handleSelectionChanged(args: Self.TimeRange.RangeChangedArgs): void;

	}

	export namespace TimeRangePicker {
		interface Options extends Self.Picker.Options {
		}

	}

	export class TimeSelectorPicker extends Self.Picker {
		constructor(options: Self.TimeSelectorPicker.Options);

		private _handleSelectionChanged(args: Self.TimePicker.TimeChangedArgs): void;

	}

	export namespace TimeSelectorPicker {
		interface Options extends Self.Picker.Options {
		}

	}

	export class ToggleGroup extends PackageCore.Component {
		constructor(options?: Self.ToggleGroup.Options);

		buttons: globalThis.Array<Self.ToggleGroup.Button>;

		children: PackageCore.VDom.Children;

		selectedValues: globalThis.Array<Self.ToggleGroup.Value>;

		type: Self.ToggleGroup.Type;

		toggleStrategy: Self.ToggleGroup.ToggleStrategy;

		layout: Self.ToggleGroup.Layout;

		defaultButtonOptions: Self.ToggleGroup.Button;

		onSelectionChanged: (Self.ToggleGroup.SelectionChangedCallback | null);

		select(values: (Self.ToggleGroup.Value | globalThis.Array<Self.ToggleGroup.Value>), options?: {triggerIndex?: (number | null); triggerValue?: any; triggerButton?: (Self.Button | null); reason?: (string | symbol)}): void;

		private parseChildren(children: PackageCore.VDom.Children): globalThis.Array<Self.ToggleGroup.Button>;

		private createButtons(): globalThis.Array<PackageCore.JSX.Element>;

		private handleButtonClick(triggerValue: any, triggerIndex: number): void;

		private checkNumberOfSelectedValues(selectedValuesCount: number): void;

		private focusButton(index: number): void;

		private focusNextButton(): boolean;

		private focusPreviousButton(): boolean;

		private focusFirstButton(): boolean;

		private focusLastButton(): boolean;

		private focusQueryButton(query: PackageCore.Array.FindResult): boolean;

		static singleSelection(toggleGroupOptions: Self.ToggleGroup.Options): Self.ToggleGroup;

		static SingleSelection(props: Self.ToggleGroup.Options): PackageCore.JSX.Element;

		static multiSelection(toggleGroupOptions: Self.ToggleGroup.Options): Self.ToggleGroup;

		static MultiSelection(props: Self.ToggleGroup.Options): PackageCore.JSX.Element;

		static Event: Self.ToggleGroup.EventTypes;

		static Item(props: Self.ToggleGroup.Button): PackageCore.JSX.Element;

	}

	export namespace ToggleGroup {
		interface Button {
			action?: (args: Self.Button.ActionArgs) => void;

			icon?: Self.Image.Source;

			iconPosition?: Self.Button.IconPosition;

			label?: (string | PackageCore.Translation);

			size?: Self.Button.Size;

			value: any;

			badge?: (boolean | string | number | Self.Button.BadgeDefinition);

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTION_CHANGED: string;

		}

		interface ButtonObject {
			button: Self.Button;

			value: any;

		}

		type Value = (string | number | symbol);

		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			buttons?: globalThis.Array<Self.ToggleGroup.Button>;

			defaultButtonOptions?: Self.ToggleGroup.Button;

			layout?: Self.ToggleGroup.Layout;

			selectedValues?: (Self.ToggleGroup.Value | globalThis.Array<Self.ToggleGroup.Value>);

			toggleStrategy?: Self.ToggleGroup.ToggleStrategy;

			type?: Self.ToggleGroup.Type;

			onSelectionChanged?: Self.ToggleGroup.SelectionChangedCallback;

		}

		type SelectionChangedCallback = (args: Self.ToggleGroup.SelectionChangedArgs, sender: Self.ToggleGroup) => void;

		interface SelectionChangedArgs {
			triggerIndex: (number | null);

			triggerValue: any;

			triggerButton: (Self.Button | null);

			selectedValues: globalThis.Array<Self.ToggleGroup.Value>;

			previousSelectedValues: globalThis.Array<Self.ToggleGroup.Value>;

			reason: Self.ToggleGroup.Reason;

		}

		enum Layout {
			COMPACT,
			LOOSE,
		}

		enum ToggleStrategy {
			ZERO_TO_ONE,
			ALWAYS_ONE,
			ONE_TO_MANY,
			ZERO_TO_MANY,
		}

		enum Type {
			DEFAULT,
			GHOST,
			PURE,
		}

		enum Reason {
			CALL,
			UPDATE,
			USER_SELECTION,
		}

	}

	export class TogglePicker extends Self.Picker {
		constructor(options: object);

		open(args?: object): void;

	}

	export namespace TogglePicker {
	}

	export class ToolBar extends PackageCore.Component {
		constructor(options?: Self.ToolBar.Options);

		components: globalThis.Array<PackageCore.Component>;

		children: PackageCore.VDom.Children;

		focusableItems: globalThis.Array<PackageCore.Component>;

		orientation: Self.ToolBar.Orientation;

		wrap: boolean;

		add(components: (PackageCore.Component | globalThis.Array<PackageCore.Component>), options?: {index?: number; reason?: string}): Self.ToolBar;

		remove(componentOrIndex: (PackageCore.Component | number)): Self.ToolBar;

		clear(): Self.ToolBar;

		has(component: PackageCore.Component): boolean;

		setOrientation(orientation: Self.ToolBar.Orientation): void;

		selectFirstItem(): boolean;

		selectLastItem(): boolean;

		selectNextItem(): boolean;

		selectPreviousItem(): boolean;

		selectItem(item: PackageCore.Component): void;

		static Horizontal(props: Self.ToolBar.Options): PackageCore.JSX.Element;

		static Vertical(props: Self.ToolBar.Options): PackageCore.JSX.Element;

		static Event: Self.ToolBar.EventTypes;

	}

	export namespace ToolBar {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items?: globalThis.Array<PackageCore.Component>;

			orientation?: Self.ToolBar.Orientation;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ADDED: string;

			ITEM_REMOVED: string;

		}

		enum VisualStyle {
			SMALL,
			MEDIUM,
			LARGE,
			XLARGE,
			PLAIN,
		}

		export import Orientation = Self.ToolBarConstant.Orientation;

		export import Reason = Self.ToolBarConstant.Reason;

		export import Group = Self.ToolBarGroup;

	}

	namespace ToolBarConstant {
		enum Reason {
			CALL,
		}

		enum Orientation {
			VERTICAL,
			HORIZONTAL,
		}

	}

	export class ToolBarGroup extends PackageCore.Component {
		constructor(options?: Self.ToolBarGroup.Options);

		components: globalThis.Array<PackageCore.Component>;

		children: PackageCore.VDom.Children;

		focusableItems: globalThis.Array<PackageCore.Component>;

		add(components: (PackageCore.Component | globalThis.Array<PackageCore.Component>), options?: {index?: number; reason?: string}): Self.ToolBarGroup;

		remove(componentOrIndex: (PackageCore.Component | number)): Self.ToolBarGroup;

		clear(): Self.ToolBarGroup;

		static create(): Self.ToolBarGroup;

		static Event: Self.ToolBarGroup.EventTypes;

	}

	export namespace ToolBarGroup {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			items?: globalThis.Array<PackageCore.Component>;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			ITEM_ADDED: string;

			ITEM_REMOVED: string;

		}

	}

	export class Tooltip implements PackageCore.EventSource {
		on(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		off(eventName: (PackageCore.EventSource.EventName | globalThis.Array<PackageCore.EventSource.EventName> | PackageCore.EventSource.ListenerMap), listener?: PackageCore.EventSource.Listener): void;

		protected _fireEvent(eventName: PackageCore.EventSource.EventName, args?: any): void;

		protected _disposeEvents(): void;

		private _addEventListener(eventName: PackageCore.EventSource.EventName, listener: PackageCore.EventSource.Listener): PackageCore.EventSource.Handle;

		protected _checkDeprecatedEvent(eventName: PackageCore.EventSource.EventName): void;

		constructor(options?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element | Self.Tooltip.ContentCallback | Self.Tooltip.Options));

		component: (PackageCore.Component | Element | null);

		content: (PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | Self.Tooltip.ContentCallback | null);

		contentGap: (Self.Tooltip.GapSize | Self.Tooltip.GapSizeObject);

		position: PackageCore.PositionHelper.Options;

		opened: boolean;

		opening: boolean;

		closing: boolean;

		status: PackageCore.Component.Status;

		size: Self.Tooltip.Size;

		attachTo(component: (PackageCore.Component | Element)): void;

		detach(): void;

		setContent(content: (PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | Self.Tooltip.ContentCallback | null)): void;

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

		open(options?: PackageCore.PositionHelper.Options & {component?: (PackageCore.Component | Element); reason?: string}): void;

		close(options?: {reason?: string}): void;

		resize(): void;

		dispose(): void;

		private detachCloseTimer(): void;

		static show(options: Self.Tooltip.Options): void;

		static defaultAlignment: globalThis.Array<PackageCore.PositionHelper.Alignment>;

		static Event: Self.Tooltip.EventTypes;

		static Target(props: {tooltip?: Self.Tooltip; target?: PackageCore.VDomRef}): PackageCore.JSX.Element;

	}

	export namespace Tooltip {
		interface Options extends PackageCore.Component.Options {
			closeStrategy?: Self.Window.CloseStrategyHandler;

			closeTimeout?: number;

			component?: (PackageCore.Component | Element);

			content: (PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | Self.Tooltip.ContentCallback | null);

			contentGap?: (Self.Tooltip.GapSize | Self.Tooltip.GapSizeObject);

			openOnOwnerDisabled?: boolean;

			openStrategy?: (args: object) => boolean;

			position?: (PackageCore.PositionHelper.Options | (() => PackageCore.PositionHelper.Options));

			status?: PackageCore.Component.Status;

			size?: Self.Tooltip.Size;

			visualStyle?: Self.Tooltip.VisualStyle;

			anchorStyle?: Self.Window.AnchorVisualStyleCallback;

			on?: PackageCore.EventSource.ListenerMap;

		}

		type ContentCallback = () => (PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | null);

		interface GapSizeObject {
			top?: Self.Tooltip.GapSize;

			bottom?: Self.Tooltip.GapSize;

			start?: Self.Tooltip.GapSize;

			end?: Self.Tooltip.GapSize;

			horizontal?: Self.Tooltip.GapSize;

			vertical?: Self.Tooltip.GapSize;

		}

		interface EventTypes {
			OPENING: string;

			OPENED: string;

			CLOSING: string;

			CLOSED: string;

		}

		enum Position {
			toCursor,
			toTarget,
			toCursorOrTarget,
		}

		export import Size = Self.Popover.Size;

		export import OpenReason = Self.TooltipOpenReason;

		export import OpenStrategy = Self.TooltipOpenStrategy;

		export import CloseStrategy = Self.WindowCloseStrategy;

		enum VisualStyle {
			TOOLTIP,
			POPOVER,
		}

		export import GapSize = Self.Popover.GapSize;

	}

	export enum TooltipOpenReason {
		CALL,
		FOCUS_IN,
		MOUSE_IN,
		MOUSE_MOVE,
	}

	export namespace TooltipOpenStrategy {
	}

	class Tree extends PackageCore.Component {
		constructor(options?: Self.Tree.Options);

		expandable: boolean;

		expanded: boolean;

		collapsible: boolean;

		showTreeLines: boolean;

		level: number;

		spacing: Self.Tree.HierarchySpacing;

		hierarchy: globalThis.Array<any>;

		static Event: Self.Tree.EventTypes;

	}

	namespace Tree {
		interface Options extends PackageCore.Component.Options {
		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			EXPANDED: string;

		}

		export import HierarchySpacing = Self.TreeConstant.HierarchySpacing;

	}

	export class TreeCell extends Self.GridCell {
		constructor();

		withHierarchy: boolean;

		showTreeLines: boolean;

		hierarchyExpanded: boolean;

		hasDetailRow: boolean;

		detailExpanded: boolean;

		updateHierarchyExpand(): void;

		updateDetailExpand(): void;

		static defaultRenderer(): Self.Text;

	}

	export namespace TreeCell {
	}

	class TreeChildCounter extends PackageCore.Component {
		constructor(options?: Self.TreeChildCounter.Options);

		format: Self.TreeChildCounter.Format;

		showEmpty: boolean;

		visibleCount: number;

		totalCount: number;

	}

	namespace TreeChildCounter {
		interface Options extends PackageCore.Component.Options {
		}

		enum VisualStyle {
			DEFAULT,
		}

		enum Format {
			COUNT_ONLY,
			TOTAL_ONLY,
			COUNT_AND_TOTAL,
			FRACTION,
		}

	}

	export class TreeColumn extends Self.GridColumn {
		constructor(options: Self.TreeColumn.Options);

		showTreeLines: boolean;

		withHierarchy: boolean;

		content: (((args: {cell: Self.TreeCell}) => PackageCore.JSX.Element) | null);

		handleExpanded(value: boolean): void;

	}

	export namespace TreeColumn {
		interface Options extends Self.GridColumn.Options {
			showTreeLines?: boolean;

			withHierarchy?: boolean;

			autoWidth?: boolean;

			content?: Self.TreeColumn.ContentCallback;

		}

		type ContentCallback = (args: Self.TreeColumn.ContentArgs) => (PackageCore.Component | PackageCore.JSX.Element);

		interface ContentArgs {
			cell: Self.TreeCell;

		}

		export import Cell = Self.TreeCell;

	}

	namespace TreeConstant {
		enum HierarchySpacing {
			COMPACT,
			DEFAULT,
		}

		enum SelectionMode {
			INDEPENDENT,
			GROUP,
		}

		enum DropPosition {
			BEFORE,
			AFTER,
			INSIDE,
		}

		enum Reason {
			CURSOR_SET,
			SELECT,
			UNSELECT,
			MULTI_SELECT_DISABLED,
			SELECTABLE_DISABLED,
			DATA_LOADED,
			DATA_REMOVED,
			DATA_MOVED,
			DATA_RESET,
			DATA_BIND,
			DATA_UNBIND,
			CLICK,
			KEY_DOWN,
			CHECK_UPDATE,
		}

	}

	export namespace TreeDataExchange {
		function dragSource(options: object): PackageCore.DataExchange.DragSourceProvider;

		function dragTarget(options: object): PackageCore.DataExchange.DragTargetProvider;

	}

	export class TreeItem extends PackageCore.Component {
		constructor();

		treeView: Self.TreeView;

		parentItem: Self.TreeItem;

		childItems: globalThis.Array<Self.TreeItem>;

		visibleChildItems: globalThis.Array<Self.TreeItem>;

		childCount: number;

		visibleChildCount: number;

		empty: boolean;

		visibleEmpty: boolean;

		index: number;

		flatVisibleIndex: number;

		indexPath: Self.ListBox.IndexPath;

		level: number;

		dataEntry: object;

		dataItem: any;

		dataBound: boolean;

		loaded: boolean;

		loading: boolean;

		height: number;

		userData: object;

		renderData: (object | null);

		label: string;

		selectable: boolean;

		effectiveSelectable: boolean;

		draggable: boolean;

		effectiveDraggable: boolean;

		selected: boolean;

		effectiveVisible: boolean;

		filtered: boolean;

		expanded: boolean;

		expandable: boolean;

		collapsible: boolean;

		virtualization: boolean;

		content: (PackageCore.Component | null);

		contentProvider: (item: Self.TreeItem, renderData: object) => PackageCore.JSX.Element;

		totalChildCount: number;

		totalVisibleChildCount: number;

		childCounter: (object | null);

		actionControls: (PackageCore.Component | PackageCore.JSX.Element | globalThis.Array<(PackageCore.Component | PackageCore.JSX.Element)> | null);

		checkValue: (boolean | null);

		dropIndicator: Self.TreeItem.DropPosition;

		addItems(items: globalThis.Array<Self.TreeItem>, options: {index: number; reason?: string}): void;

		removeItems(index: number, count: number, options: {reason?: string}): void;

		bind(entry: PackageCore.DataStoreEntry): void;

		unbind(): void;

		load(): globalThis.Promise<any>;

		loadAll(): globalThis.Promise<any>;

		expand(): void;

		expandAll(): globalThis.Promise<any>;

		expandParents(): void;

		collapse(): void;

		collapseAll(): void;

		collapseParents(): void;

		refresh(): void;

		containsItem(item: Self.TreeItem): boolean;

		getCommonParent(item: Self.TreeItem): void;

		setSelectable(value: boolean, options?: {reason?: string}): void;

		setSelected(value: boolean, options?: {reason?: string}): void;

		setCursor(value: boolean): void;

		setCursorVisible(value: boolean): void;

		setExpanded(value: boolean, options?: {reason?: string}): void;

		setCollapsible(value: boolean): void;

		setDraggable(value: boolean, options?: {reason?: string}): void;

		setHeight(value: number, options?: {reason?: string}): void;

		setChildCounter(counter: (PackageCore.Component | null)): void;

		setActionControls(controls: (PackageCore.Component | globalThis.Array<PackageCore.Component> | null)): void;

		setDropIndicator(value: Self.TreeItem.DropPosition): void;

		visit(callback: (item: Self.TreeItem) => boolean, self?: boolean): void;

		visitVisible(callback: (item: Self.TreeItem) => (boolean | null), self?: boolean): void;

		setupVirtualPosition(): void;

		countMatchingItems(visible: boolean, predicate?: (item: Self.TreeItem) => boolean): number;

		getFirstItem(onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		getLastItem(onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		getNextItem(from?: Self.TreeItem, onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		getPreviousItem(from?: Self.TreeItem, onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		static defaultContent(item: Self.TreeItem): PackageCore.JSX.Element;

		static Event: Self.TreeItem.EventTypes;

	}

	export namespace TreeItem {
		interface Options extends PackageCore.Component.Options {
			treeView: Self.TreeView;

			parentItem: Self.TreeItem;

			index: number;

			level: number;

			dataEntry?: PackageCore.DataStoreEntry;

			height: number;

			content: (item: Self.TreeItem, renderData: object) => PackageCore.JSX.Element;

			childCounter?: Self.TreeChildCounter.Options;

			selected?: boolean;

			expanded?: boolean;

			collapsible?: boolean;

		}

		interface EventTypes extends PackageCore.Component.EventTypes {
			SELECTED: string;

			SELECTABLE_CHANGED: string;

			EFFECTIVE_SELECTABLE_CHANGED: string;

			DRAGGABLE_CHANGED: string;

			EFFECTIVE_DRAGGABLE_CHANGED: string;

			VISIBLE_CHANGED: string;

			EFFECTIVE_VISIBLE_CHANGED: string;

			HEIGHT_CHANGED: string;

			ITEMS_ADDED: string;

			ITEMS_REMOVED: string;

			EXPANDED: string;

			LOADING_STARTED: string;

			LOADING_FINISHED: string;

			VISIBLE_CHILDREN_CHANGED: string;

		}

		enum VisualStyle {
			DEFAULT,
		}

		export import DropPosition = Self.TreeConstant.DropPosition;

	}

	export class TreeView extends Self.DataSourceComponent {
		constructor(options?: Self.TreeView.Options);

		selectedItems: globalThis.Array<any>;

		selectedTreeItems: globalThis.Array<Self.TreeItem>;

		selectedIndexPaths: globalThis.Array<Self.TreeView.IndexPath>;

		selectable: boolean;

		draggable: boolean;

		multiSelect: boolean;

		lockedLevels: number;

		displayMember: (Self.DataSourceComponent.DisplayMember | null);

		cursorItem: Self.TreeItem;

		cursorVisibility: Self.TreeView.CursorVisibility;

		initialCursorPosition: Self.TreeView.InitialCursorPosition;

		moveSelectionWithCursor: boolean;

		rootItem: Self.TreeItem;

		items: globalThis.Array<Self.TreeItem>;

		visibleItems: globalThis.Array<Self.TreeItem>;

		empty: boolean;

		visibleEmpty: boolean;

		placeholder: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

		virtualization: boolean;

		showTreeLines: boolean;

		showItemLoaders: boolean;

		clickToExpand: boolean;

		clickToSelect: boolean;

		hierarchySpacing: Self.TreeView.HierarchySpacing;

		totalItemCount: number;

		totalVisibleItemCount: number;

		preload: Self.TreeView.Preload;

		withChecks: boolean;

		withBorder: boolean;

		selectionMode: Self.TreeView.SelectionMode;

		itemContent: (((item: Self.TreeItem, renderData: object) => (PackageCore.Component | PackageCore.JSX.Element)) | null);

		onSelectionChanged: (Self.TreeView.SelectionChangedCallback | null);

		select(options: {items?: globalThis.Array<any>; treeItems?: globalThis.Array<Self.TreeItem>; indexPaths?: globalThis.Array<any>; predicate?: (item: Self.TreeItem) => boolean; append?: boolean; reason?: string}): boolean;

		unselect(options: {items?: globalThis.Array<any>; treeItems?: globalThis.Array<Self.TreeItem>; indexPaths?: globalThis.Array<any>; predicate?: (item: Self.TreeItem) => boolean; reason?: string}): boolean;

		selectAll(options?: {reason?: string}): boolean;

		selectAllVisible(options?: {reason?: string}): boolean;

		unselectAll(options?: {reason?: string}): boolean;

		selectGroup(root: Self.TreeItem, reason?: string): void;

		unselectGroup(root: Self.TreeItem, reason?: string): void;

		toggleGroup(item: Self.TreeItem, reason?: string): void;

		toggleItem(item: Self.TreeItem, reason?: string): void;

		filter(predicate: (item: Self.TreeItem) => boolean): void;

		itemAtIndexPath(indexPath: Self.TreeView.IndexPath): (Self.TreeItem | null);

		itemForElement(element: Element): (Self.TreeItem | null);

		itemForDataItem(dataItem: any): (Self.TreeItem | null);

		scrollTo(args: {treeItem?: Self.TreeItem; item?: any; indexPath?: Self.TreeView.IndexPath; reason?: string}): void;

		scrollToSelection(): void;

		setSelectable(value: boolean): void;

		setDraggable(value: boolean): void;

		setMultiSelect(value: boolean): void;

		setVirtualization(value: boolean): void;

		setCursorItem(item: (Self.TreeItem | null), options?: {reason?: string}): void;

		setCursorVisibility(cursorVisibility: Self.TreeView.CursorVisibility): void;

		setMoveSelectionWithCursor(value: boolean): void;

		setPlaceholder(value: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element)): void;

		setPreload(value: Self.TreeView.Preload): void;

		setShowItemLoaders(value: boolean): void;

		getFirstItem(onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		getLastItem(onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		getNextItem(from: Self.TreeItem, onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		getPreviousItem(from: Self.TreeItem, onlyVisible?: boolean, predicate?: (item: Self.TreeItem) => boolean): (Self.TreeItem | null);

		visit(callback: (item: Self.TreeItem) => boolean): void;

		visitVisible(callback: (item: Self.TreeItem) => boolean): void;

		countMatchingItems(visible: boolean, predicate?: (item: Self.TreeItem) => boolean): number;

		expandAll(): globalThis.Promise<any>;

		expandPath(selector: (level: number, items: globalThis.Array<Self.TreeItem>) => Self.TreeItem): globalThis.Promise<any>;

		expandPathToDataItem(dataItem: any): globalThis.Promise<any>;

		expandIndexPath(indexPath: Self.TreeView.IndexPath): globalThis.Promise<any>;

		collapseAll(): void;

		collapsePath(selector: (level: number, items: globalThis.Array<Self.TreeItem>) => Self.TreeItem): void;

		collapseIndexPath(indexPath: Self.TreeView.IndexPath): void;

		loadAll(): globalThis.Promise<any>;

		loadPath(selector: (level: number, items: globalThis.Array<Self.TreeItem>) => Self.TreeItem): globalThis.Promise<any>;

		loadIndexPath(indexPath: Self.TreeView.IndexPath): globalThis.Promise<any>;

		static defaultItemContent(): PackageCore.JSX.Element;

		static Event: Self.TreeView.EventTypes;

	}

	export namespace TreeView {
		type IndexPath = globalThis.Array<number>;

		interface Options extends Self.DataSourceComponent.Options {
			childCounter?: (boolean | object | ((dataItem: any) => Self.TreeChildCounter.Options));

			clickToExpand?: boolean;

			clickToSelect?: boolean;

			cursorVisibility?: Self.TreeView.CursorVisibility;

			customizeItem?: Self.TreeView.CustomizeItemCallback;

			displayMember?: Self.DataSourceComponent.DisplayMember;

			draggable?: boolean;

			hierarchySpacing?: Self.TreeView.HierarchySpacing;

			initialCursorPosition?: Self.TreeView.InitialCursorPosition;

			itemContent?: (item: Self.TreeItem, renderData: object) => (PackageCore.Component | PackageCore.JSX.Element);

			itemDragSource?: PackageCore.DataExchange.DragSourceProvider;

			itemHeight?: number;

			itemLoader?: object;

			itemReorder?: boolean;

			keepSelection?: boolean;

			lockedLevels?: number;

			moveSelectionWithCursor?: boolean;

			multiSelect?: boolean;

			placeholder?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			preload?: Self.TreeView.Preload;

			selectable?: boolean;

			selectedItems?: globalThis.Array<any>;

			selectionMode?: Self.TreeView.SelectionMode;

			showItemLoaders?: boolean;

			showTreeLines?: boolean;

			stickyGroupHeaders?: boolean;

			virtualization?: boolean;

			withChecks?: boolean;

			expanded?: boolean;

			onSelectionChanged?: Self.TreeView.SelectionChangedCallback;

		}

		type SelectionChangedCallback = (args: Self.TreeView.SelectionChangedArgs, sender: Self.TreeView) => void;

		type CustomizeItemCallback = (item: Self.TreeItem) => void;

		interface SelectionChangedArgs {
			items: globalThis.Array<any>;

			previousItems: globalThis.Array<any>;

			addedItems: globalThis.Array<any>;

			removedItems: globalThis.Array<any>;

			reason: Self.TreeView.Reason;

		}

		interface EventTypes extends Self.DataSourceComponent.EventTypes {
			SELECTION_CHANGED: string;

			CURSOR_MOVED: string;

			ITEMS_ADDED: string;

			ITEMS_REMOVED: string;

			ITEM_EXPANDED: string;

			ITEM_LOADING_STARTED: string;

			ITEM_LOADING_FINISHED: string;

		}

		enum VisualStyle {
			DEFAULT,
			EMBEDDED,
		}

		export import DataExchange = Self.TreeDataExchange;

		export import Item = Self.TreeItem;

		export import ItemVisualStyle = Self.TreeItem.VisualStyle;

		enum Reason {
		}

		enum InitialCursorPosition {
			NONE,
			FIRST,
			FIRST_SELECTED,
		}

		enum CursorVisibility {
			FOCUS,
			ALWAYS,
		}

		enum Preload {
			NONE,
			VISIBLE,
			ALL,
		}

		export import HierarchySpacing = Self.TreeConstant.HierarchySpacing;

		export import SelectionMode = Self.TreeConstant.SelectionMode;

		export import CounterFormat = Self.TreeChildCounter.Format;

	}

	namespace UifBundle {
	}

	class VirtualListView extends PackageCore.Component {
		constructor();

		stickyGroupHeaders: boolean;

		scrollTo(item: object): void;

		static Event: Self.VirtualListView.EventTypes;

	}

	namespace VirtualListView {
		interface EventTypes extends PackageCore.Component.EventTypes {
			SCROLL_TO_END: string;

		}

	}

	class VirtualTreeContainer extends PackageCore.Component {
		constructor();

	}

	namespace VirtualTreeContainer {
	}

	export enum VisualizationColor {
		NEUTRAL,
		SUCCESS,
		WARNING,
		DANGER,
		INFO,
		TEAL,
		ORANGE,
		TURQUOISE,
		TAUPE,
		GREEN,
		PINK,
		BROWN,
		LILAC,
		YELLOW,
		PURPLE,
		BLUE,
		PINE,
	}

	export abstract class Window extends PackageCore.Component implements PackageCore.Portal {
		protected constructor(options: Self.Window.Options);

		content: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element | null);

		contentGap: (Self.Window.GapSize | Self.Window.GapSizeObject);

		buttons: (globalThis.Array<Self.Button> | PackageCore.Component | null);

		buttonsJustification: Self.Window.ButtonsJustification;

		icon: (Self.Image.Source | null);

		label: (string | PackageCore.Translation | PackageCore.Component | null);

		footerContent: (string | PackageCore.Translation | PackageCore.Component | null);

		parentWindow: (Self.Window | null);

		owner: (PackageCore.Component | PackageCore.VDomRef | Element);

		childWindows: globalThis.Array<Self.Window>;

		level: number;

		layer: number;

		opened: boolean;

		opening: boolean;

		closing: boolean;

		modal: boolean;

		state: Self.Window.State;

		resizable: boolean;

		pointerEvents: boolean;

		open(options?: Self.Window.OpenArgs): void;

		close(options?: object): void;

		maximize(options?: {reason?: string}): void;

		restore(options?: {reason?: string}): void;

		setContent(content: (PackageCore.Component | string | PackageCore.Translation | PackageCore.JSX.Element | null)): void;

		setState(state: Self.Window.State, options?: {reason?: string}): void;

		resize(options?: object): void;

		position(options?: (Self.Window.PositionArgs | null), updateSize?: boolean): void;

		private setRootElementStyle(position: PackageCore.Rectangle): void;

		private alignToDocumentBody(coordinates: PackageCore.PositionHelper.FrameDescription): PackageCore.Rectangle;

		private getPositionOptions(options: PackageCore.PositionHelper.Options, measuredSize: object): PackageCore.PositionHelper.Options;

		static findManagingWindow(): void;

		static defaultFocusHandler(): void;

		static Event: Self.Window.EventTypes;

	}

	export namespace Window {
		interface Options extends PackageCore.Component.Options {
			allowClip?: boolean;

			autoResize?: boolean;

			buttons?: (globalThis.Array<Self.Button> | PackageCore.Component);

			buttonsJustification?: Self.Window.ButtonsJustification;

			closeStrategy?: Self.Window.CloseStrategyHandler;

			content?: (string | PackageCore.Translation | PackageCore.Component | PackageCore.JSX.Element);

			contentGap?: (Self.Window.GapSize | Self.Window.GapSizeObject);

			footerContent?: (string | PackageCore.Translation | PackageCore.Component);

			getFocusComponent?: (body: Self.WindowBody, focusManager: PackageCore.FocusManager) => (Element | PackageCore.Component);

			icon?: Self.Image.Source;

			label?: (string | PackageCore.Translation | PackageCore.Component);

			modal?: boolean;

			owner: (PackageCore.Component | PackageCore.VDomRef | Element);

			position?: Self.Window.PositionArgs;

			resizable?: boolean;

			role?: Self.Window.Role;

			tabbable?: boolean;

			withAnchor?: boolean;

			anchorStyle?: Self.Window.AnchorVisualStyleCallback;

			pointerEvents?: boolean;

		}

		interface OpenArgs {
			closeStrategy?: Self.Window.CloseStrategyHandler;

			position?: Self.Window.PositionArgs;

			reason?: string;

		}

		type Target = (PackageCore.VDomRef | PackageCore.Component | Element | string | PackageCore.PositionHelper.Point | PackageCore.Rectangle | PackageCore.PositionHelper.TargetPoint);

		interface PositionArgs {
			alignment?: (PackageCore.PositionHelper.Alignment | globalThis.Array<PackageCore.PositionHelper.Alignment>);

			alignmentOffset?: number;

			allowed?: (PackageCore.PositionHelper.Placement | globalThis.Array<PackageCore.PositionHelper.Placement>);

			allowOverlapOuterContainer?: boolean;

			outerContainer?: (HTMLElement | PackageCore.Rectangle);

			placement?: (PackageCore.PositionHelper.Placement | globalThis.Array<PackageCore.PositionHelper.Placement>);

			placementOffset?: number;

			rtl?: boolean;

			size?: PackageCore.PositionHelper.SizeOptions;

			strategy?: PackageCore.PositionHelper.Strategy;

			target?: Self.Window.Target;

		}

		interface GapSizeObject {
			top?: Self.Window.GapSize;

			bottom?: Self.Window.GapSize;

			start?: Self.Window.GapSize;

			end?: Self.Window.GapSize;

			horizontal?: Self.Window.GapSize;

			vertical?: Self.Window.GapSize;

		}

		type AnchorVisualStyleCallback = (theme: PackageCore.Theme) => PackageCore.Style;

		type CloseStrategyHandler = (window: Self.Window) => PackageCore.RoutedMessage.Filter;

		interface EventTypes extends PackageCore.Component.EventTypes {
			OPENING: string;

			OPENED: string;

			CLOSING: string;

			CLOSED: string;

			MOVED: string;

			USER_RESIZING: string;

			USER_RESIZED: string;

			STATE_CHANGED: string;

		}

		enum VisualStyle {
			MODAL,
			POPOVER,
			PICKER,
			TOOLTIP,
		}

		enum State {
			FLOATING,
			MAXIMIZED,
		}

		enum Role {
			CONTEXT_MENU,
			POPOVER,
			MODAL,
			TOOLTIP,
		}

		export import CloseReason = Self.WindowCloseReason;

		export import CloseStrategy = Self.WindowCloseStrategy;

		export import ButtonsJustification = Self.WindowBody.ButtonsJustification;

		export import GapSize = Self.GapSize;

		export import Position = PackageCore.PositionHelper;

		enum defaultPopupOptions {
			autoResize,
			focusOnOpen,
			withTitleBar,
			resizable,
			closeStrategy,
			role,
			visualStyle,
		}

	}

	class WindowBody extends PackageCore.Component {
		constructor(options?: Self.WindowBody.Options);

		label: (string | PackageCore.Translation | PackageCore.Component | null);

		icon: (Self.Image.Source | null);

		children: (string | PackageCore.Translation | PackageCore.Component);

		buttons: (globalThis.Array<Self.Button> | PackageCore.Component);

		buttonsJustification: Self.Window.ButtonsJustification;

		footerContent: (string | PackageCore.Translation | PackageCore.Component | null);

		contentGap: (Self.Window.GapSize | Self.Window.GapSizeObject);

		hasLabel: boolean;

		hasIcon: boolean;

		hasFooter: boolean;

	}

	namespace WindowBody {
		interface Options extends PackageCore.Component.Options {
			children?: PackageCore.VDom.Children;

			content?: (string | PackageCore.Translation | PackageCore.Component);

			icon?: Self.Image.Source;

			label?: (string | PackageCore.Translation | PackageCore.Component);

			buttons?: (globalThis.Array<Self.Button> | PackageCore.Component);

			buttonsJustification?: Self.Window.ButtonsJustification;

			footerContent?: (string | PackageCore.Translation | PackageCore.Component);

			contentGap?: (Self.Window.GapSize | Self.Window.GapSizeObject);

		}

		enum ButtonsJustification {
			START,
			END,
			CENTER,
		}

	}

	export enum WindowCloseReason {
		CALL,
		FOCUSED,
		FOCUS_IN,
		FOCUS_OUT,
		ACTIVATED,
		ENTER,
		ESCAPE,
		SPACE,
		KEY,
		MOUSE_MOVE,
		MOUSE_LEAVE,
		CLICK,
		TOUCH,
		SCROLL,
		PARENT_CLOSED,
		CLOSE_BUTTON,
		DISPOSED,
		ITEM_ACTION,
		TIMEOUT,
		OK_BUTTON,
		CANCEL_BUTTON,
	}

	export class WindowCloseStrategy {
		static DEFAULT_MOUSE_DELAY: number;

		static focusOutside(component: (PackageCore.Component | null), options: (object | null)): Self.Window.CloseStrategyHandler;

		static mouseOutside(component: (PackageCore.Component | null), options: (object | null)): Self.Window.CloseStrategyHandler;

		static clickOutside(component: (PackageCore.Component | null), options: (object | null)): Self.Window.CloseStrategyHandler;

		static scrollOutside(component: (PackageCore.Component | null), options: (object | null)): Self.Window.CloseStrategyHandler;

		static key(key: PackageCore.KeyCode, options: (object | null)): Self.Window.CloseStrategyHandler;

		static escape(): Self.Window.CloseStrategyHandler;

		static none(): Self.Window.CloseStrategyHandler;

		static anyOf(strategies: globalThis.Array<Self.Window.CloseStrategyHandler>): Self.Window.CloseStrategyHandler;

		static custom(options: object): Self.Window.CloseStrategyHandler;

		static default(options: object): Self.Window.CloseStrategyHandler;

		static popover(component?: PackageCore.Component, options?: object): Self.Window.CloseStrategyHandler;

		static focusedOrOver(component: (PackageCore.Component | null), options?: object): Self.Window.CloseStrategyHandler;

	}

	export namespace WindowCloseStrategy {
	}

	class WindowDragger {
		constructor(options?: object);

		attach(): void;

		detach(): void;

		processMessage(next: PackageCore.RoutedMessage.Handler, message: PackageCore.RoutedMessage, result: PackageCore.RoutedMessage.Result): void;

	}

	namespace WindowDragger {
	}

	export class WindowTitleBar extends PackageCore.Component {
		constructor(options?: Self.WindowTitleBar.Options);

		title: (string | number | PackageCore.Translation);

		maximizeButton: boolean;

		closeButton: boolean;

		icon: Self.Image.Source;

		draggable: boolean;

		onButton: Self.WindowTitleBar.ButtonCallback;

		onMove: Self.WindowTitleBar.MoveCallback;

	}

	export namespace WindowTitleBar {
		interface Options extends PackageCore.Component.Options {
			title?: (string | number | PackageCore.Translation);

			icon?: Self.Image.Source;

			maximizeButton?: boolean;

			closeButton?: boolean;

			draggable?: boolean;

			onButton?: Self.WindowTitleBar.ButtonCallback;

			onMove?: Self.WindowTitleBar.MoveCallback;

		}

		type ButtonCallback = (args: Self.WindowTitleBar.ButtonCallbackArgs) => void;

		interface ButtonCallbackArgs {
			button: Self.WindowTitleBar.Button;

		}

		type MoveCallback = (coordinates: PackageCore.PointerMessage.Coordinates) => void;

		enum VisualStyle {
			DEFAULT,
		}

		enum Button {
			MINIMIZE,
			MAXIMIZE,
			CLOSE,
		}

	}

	export function createActionColumn(columnOptions: Omit<Self.ActionColumn.Options, "type">): Self.ActionColumn.Options;

	export function createTemplatedColumn(columnOptions: Omit<Self.TemplatedColumn.Options, "type">): Self.TemplatedColumn.Options;

}