@oracle/netsuite-uif-types/uif/component.d.ts

NetSuite UI Framework TypeScript type declarations

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: PackageCor