x4js 2.0.8 → 2.0.9

package/lib/output.d.ts

@@ -0,0 +1,1472 @@
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @author Etienne Cochard 
+ * @copyright (c) 2024 R-libre ingenierie
+ *
+ * Use of this source code is governed by an MIT-style license 
+ * that can be found in the LICENSE file or at https://opensource.org/licenses/MIT.
+ *
+ * AUTOGENERATED CODE, DO NOT MODIFY
+ * generated on Fri Oct 04 2024
+ */
+
+
+declare module 'x4js' {
+
+	// ---------------------------------------
+	// from /src/core/core_i18n.ts
+
+	interface Language  {
+		name: string;
+		base: string;
+		src_translations: any;
+		translations: any;
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_tools.ts
+
+	type Constructor<P> = {
+		new( params: any[] ): P;
+	}
+
+	export class UnsafeHtml extends String {
+		constructor( value: string );
+	}
+
+	export interface IRect  {
+		left: number;
+		top: number;
+		height: number;
+		width: number;
+	}
+
+	export class Rect implements IRect {
+		left: number;
+		top: number;
+		height: number;
+		width: number;
+		constructor(  );
+		constructor( l: number, t: number, w: number, h: number );
+		constructor( l: Rect );
+		constructor( l: number | IRect, t: number, w: number, h: number );
+	}
+
+	export interface Point  {
+		x: number;
+		y: number;
+	}
+
+	export interface IComponentInterface  {
+	}
+
+	export interface IFormElement extends IComponentInterface {
+		getRawValue(  ): any;
+		setRawValue( v: any ): void;
+	}
+
+	interface Features  {
+		eyedropper: 1;
+	}
+
+	export class Timer  {
+		_timers: Map<string,any>;
+		setTimeout( name: string, time: number, callback: Function ): void;
+		clearTimeout( name: string ): void;
+		setInterval( name: string, time: number, callback: Function ): void;
+		clearInterval( name: string ): void;
+		clearAllTimeouts(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_events.ts
+
+	export interface CoreEvent  {
+		type?: string;
+		source?: CoreElement;
+		context?: any;
+		propagationStopped?: boolean;
+		defaultPrevented?: boolean;
+		stopPropagation(  ): void;
+		preventDefault(  ): void;
+	}
+
+	export interface EventMap  {
+	}
+
+	type EventCallback<T extends CoreEvent = CoreEvent> = (event: T) => any;
+
+	export class EventSource<E extends EventMap = EventMap>  {
+		_source: unknown;
+		_registry: Map<string,EventCallback[]>;
+		constructor( source: unknown );
+		addListener<K extends keyof E>( name: K, callback: ( ev: E[K] ) => void, capturing: any ): void;
+		fire<K extends keyof E>( name: K, evx: E[K] ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_element.ts
+
+	export class CoreElement<E extends EventMap = EventMap>  {
+		#events: EventSource<E>;
+		#timers: Map<string, Function>;
+		__startTimer( name: string, ms: number, repeat: boolean, callback: ( ) => void ): void;
+		__stopTimer( name: string ): void;
+		setTimeout( name: string, ms: number, callback: () => void ): void;
+		clearTimeout( name: string ): void;
+		setInterval( name: string, ms: number, callback: ( ) => void ): void;
+		clearInterval( name: string ): void;
+		clearTimeouts(  ): void;
+		on<K extends keyof E>( name: K, listener: ( ev: E[K] ) => void ): void;
+		fire<K extends keyof E>( name: K, ev: E[K] ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_styles.ts
+
+	type ariaValues = {
+		"aria-activedescendant": 1;
+		"role": 1;
+	}
+
+	export class Stylesheet  {
+		m_sheet: CSSStyleSheet;
+		m_rules: Map<string, number>;
+		constructor(  );
+		setRule( name: string, definition: any ): void;
+		getVar( name: string ): any;
+		guid: number;
+		doc_style: CSSStyleDeclaration;
+	}
+
+	export class ComputedStyle  {
+		m_style: CSSStyleDeclaration;
+		constructor( style: CSSStyleDeclaration );
+		value( name: keyof CSSStyleDeclaration ): any;
+		parse( name: keyof CSSStyleDeclaration ): number;
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_dom.ts
+
+	type DOMEventHandler = ( ev: Event ) => void;
+
+	type EventEntry = Record<string,DOMEventHandler | DOMEventHandler[]>;
+
+	export interface GlobalDOMEvents  {
+		abort?: (ev: UIEvent) => any;
+		animationcancel?: (ev: AnimationEvent) => any;
+		animationend?: (ev: AnimationEvent) => any;
+		animationiteration?: (ev: AnimationEvent) => any;
+		animationstart?: (ev: AnimationEvent) => any;
+		auxclick?: (ev: MouseEvent) => any;
+		blur?: (ev: FocusEvent) => any;
+		cancel?: (ev: Event) => any;
+		canplay?: (ev: Event) => any;
+		canplaythrough?: (ev: Event) => any;
+		change?: (ev: Event) => any;
+		click?: (ev: MouseEvent) => any;
+		close?: (ev: Event) => any;
+		contextmenu?: (ev: MouseEvent) => any;
+		cuechange?: (ev: Event) => any;
+		dblclick?: (ev: MouseEvent) => any;
+		drag?: (ev: DragEvent) => any;
+		dragend?: (ev: DragEvent) => any;
+		dragenter?: (ev: DragEvent) => any;
+		dragexit?: (ev: Event) => any;
+		dragleave?: (ev: DragEvent) => any;
+		dragover?: (ev: DragEvent) => any;
+		dragstart?: (ev: DragEvent) => any;
+		drop?: (ev: DragEvent) => any;
+		durationchange?: (ev: Event) => any;
+		emptied?: (ev: Event) => any;
+		ended?: (ev: Event) => any;
+		error?: OnErrorEventHandler;
+		focusin?: (ev: FocusEvent) => any;
+		focusout?: (ev: FocusEvent) => any;
+		focus?: (ev: FocusEvent) => any;
+		gotpointercapture?: (ev: PointerEvent) => any;
+		input?: (ev: Event) => any;
+		invalid?: (ev: Event) => any;
+		keydown?: (ev: KeyboardEvent) => any;
+		keypress?: (ev: KeyboardEvent) => any;
+		keyup?: (ev: KeyboardEvent) => any;
+		load?: (ev: Event) => any;
+		loadeddata?: (ev: Event) => any;
+		loadedmetadata?: (ev: Event) => any;
+		loadstart?: (ev: Event) => any;
+		lostpointercapture?: (ev: PointerEvent) => any;
+		mousedown?: (ev: MouseEvent) => any;
+		mouseenter?: (ev: MouseEvent) => any;
+		mouseleave?: (ev: MouseEvent) => any;
+		mousemove?: (ev: MouseEvent) => any;
+		mouseout?: (ev: MouseEvent) => any;
+		mouseover?: (ev: MouseEvent) => any;
+		mouseup?: (ev: MouseEvent) => any;
+		pause?: (ev: Event) => any;
+		play?: (ev: Event) => any;
+		playing?: (ev: Event) => any;
+		pointercancel?: (ev: PointerEvent) => any;
+		pointerdown?: (ev: PointerEvent) => any;
+		pointerenter?: (ev: PointerEvent) => any;
+		pointerleave?: (ev: PointerEvent) => any;
+		pointermove?: (ev: PointerEvent) => any;
+		pointerout?: (ev: PointerEvent) => any;
+		pointerover?: (ev: PointerEvent) => any;
+		pointerup?: (ev: PointerEvent) => any;
+		progress?: (ev: ProgressEvent) => any;
+		ratechange?: (ev: Event) => any;
+		reset?: (ev: Event) => any;
+		scroll?: (ev: Event) => any;
+		securitypolicyviolation?: (ev: SecurityPolicyViolationEvent) => any;
+		seeked?: (ev: Event) => any;
+		seeking?: (ev: Event) => any;
+		select?: (ev: Event) => any;
+		selectionchange?: (ev: Event) => any;
+		selectstart?: (ev: Event) => any;
+		stalled?: (ev: Event) => any;
+		submit?: (ev: Event) => any;
+		suspend?: (ev: Event) => any;
+		timeupdate?: (ev: Event) => any;
+		toggle?: (ev: Event) => any;
+		touchcancel?: (ev: TouchEvent) => any;
+		touchend?: (ev: TouchEvent) => any;
+		touchmove?: (ev: TouchEvent) => any;
+		touchstart?: (ev: TouchEvent) => any;
+		transitioncancel?: (ev: TransitionEvent) => any;
+		transitionend?: (ev: TransitionEvent) => any;
+		transitionrun?: (ev: TransitionEvent) => any;
+		transitionstart?: (ev: TransitionEvent) => any;
+		volumechange?: (ev: Event) => any;
+		waiting?: (ev: Event) => any;
+		wheel?: (ev: WheelEvent) => any;
+		resized?: (ev: Event) => void;
+		created?: ( ev: Event ) => void;
+		removed?: ( ev: Event ) => void;
+	}
+
+	// ---------------------------------------
+	// from /src/core/component.ts
+
+	interface RefType<T extends Component>  {
+		dom: T;
+	}
+
+	type ComponentAttributes = Record<string,string|number|boolean>;
+
+	type ComponentContent = Component | string | UnsafeHtml | number | boolean | Component[];
+
+	export interface ComponentProps  {
+		tag?: string;
+		ns?: string;
+		style?: Partial<CSSStyleDeclaration>;
+		attrs?: Record<string,string|number|boolean>;
+		content?: ComponentContent;
+		dom_events?: GlobalDOMEvents;
+		cls?: string;
+		id?: string;
+		ref?: RefType<any>;
+		width?: string | number;
+		height?: string | number;
+		disabled?: true;
+		hidden?: true;
+		tooltip?: string;
+		existingDOM?: HTMLElement;
+	}
+
+	export interface ComponentEvent extends CoreEvent {
+	}
+
+	export interface ComponentEvents extends EventMap {
+	}
+
+	export class Component<P extends ComponentProps = ComponentProps, E extends ComponentEvents = ComponentEvents> extends CoreElement<E> {
+		dom: Element;
+		props: P;
+		store: Map<string|Symbol,any>;
+		constructor( props: P );
+		hasClass( cls: string ): void;
+		addClass( cls: string ): void;
+		removeClass( cls: string ): void;
+		toggleClass( cls: string ): void;
+		setClass( cls: string, set: boolean ): void;
+		setAttributes( attrs: ComponentAttributes ): void;
+		setAttribute( name: string, value: string | number | boolean ): void;
+		getAttribute( name: string ): string;
+		getData( name: string ): string;
+		setData( name: string, value: string ): void;
+		setInternalData( name: string|Symbol, value: any ): this;
+		getInternalData( name: string|Symbol ): any;
+		addDOMEvent<K extends keyof GlobalDOMEvents>( name: K, listener: GlobalDOMEvents[K], prepend: any ): void;
+		setDOMEvents( events: GlobalDOMEvents ): void;
+		mapPropEvents<N extends keyof E>( props: P, elements: N[] ): void;
+		clearContent(  ): void;
+		setContent( content: ComponentContent ): void;
+		appendContent( content: ComponentContent ): void;
+		prependContent( content: ComponentContent ): void;
+		removeChild( child: Component ): void;
+		queryAll( selector: string ): Component[];
+		query<T extends Component = Component>( selector: string ): T;
+		setAria( name: keyof ariaValues, value: string | number | boolean ): this;
+		setStyle( style: Partial<CSSStyleDeclaration> ): this;
+		setStyleValue<K extends keyof CSSStyleDeclaration>( name: K, value: CSSStyleDeclaration[K] | number ): this;
+		getStyleValue<K extends keyof CSSStyleDeclaration>( name: K ): void;
+		setWidth( w: number | string ): void;
+		setHeight( h: number | string ): void;
+		setStyleVariable( name: string, value: string ): void;
+		getStyleVariable( name: string ): void;
+		getComputedStyle(  ): void;
+		setCapture( pointerId: number ): void;
+		releaseCapture( pointerId: number ): void;
+		getBoundingRect(  ): Rect;
+		focus(  ): void;
+		scrollIntoView( arg: boolean | ScrollIntoViewOptions ): void;
+		isVisible(  ): void;
+		show( vis: any ): void;
+		hide(  ): void;
+		enable( ena: any ): void;
+		disable(  ): void;
+		isDisabled(  ): void;
+		nextElement<T extends Component = Component>(  ): T;
+		prevElement<T extends Component = Component>(  ): T;
+		parentElement<T extends Component>( cls: Constructor<T> ): T;
+		firstChild<T extends Component = Component>(  ): T;
+		lastChild<T extends Component = Component>(  ): T;
+		enumChildComponents( recursive: boolean ): void;
+		enumChildNodes( recursive: boolean ): void;
+		animate( keyframes: Keyframe[], duration: number ): void;
+		createElement( clsOrTag: string | ComponentConstructor | Symbol | Function, attrs: any, children: Component[] ): Component | Component[];
+		createFragment(  ): Component[];
+		queryInterface<T>( name: string ): T;
+	}
+
+	type ComponentConstructor = {
+		new( params: any[] ): Component;
+	}
+
+	export class Flex extends Component {
+		constructor(  );
+	}
+
+	export interface EvClick extends ComponentEvent {
+	}
+
+	export interface EvChange extends ComponentEvent {
+		value: any;
+	}
+
+	interface ISelection  {
+	}
+
+	export interface EvSelectionChange extends ComponentEvent {
+		selection: ISelection;
+	}
+
+	export interface EvContextMenu extends ComponentEvent {
+		uievent: UIEvent;
+	}
+
+	export interface EvMessage extends ComponentEvent {
+		msg: string;
+		params?: any;
+	}
+
+	export interface EvDrag extends ComponentEvent {
+		element: unknown;
+		data: any;
+	}
+
+	export interface EvError extends ComponentEvent {
+		code: number;
+		message: string;
+	}
+
+	export interface EvDblClick extends ComponentEvent {
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_colors.ts
+
+	export interface Rgb  {
+		red: number;
+		green: number;
+		blue: number;
+		alpha: number;
+	}
+
+	export interface Hsv  {
+		hue: number;
+		saturation: number;
+		value: number;
+		alpha: number;
+	}
+
+	export class Color  {
+		rgb: [red:number,green:number,blue:number,alpha:number];
+		invalid: any;
+		constructor( value: string );
+		constructor( r: number, g: number, b: number, a: number );
+		constructor( args: any[] );
+		setValue( value: string ): this;
+		setHsv( h: number, s: number, v: number, a: any ): this;
+		setRgb( r: number, g: number, b: number, a: number ): this;
+		toRgbString( withAlpha: boolean ): string;
+		toHexString(  ): string;
+		toRgb(  ): Rgb;
+		toHsv(  ): Hsv;
+		getAlpha(  ): void;
+		setAlpha( a: number ): this;
+		isInvalid(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_dragdrop.ts
+
+	interface DropInfo  {
+		pt: Point;
+		data: DataTransfer;
+	}
+
+	type DropCallback = ( command: 'enter' | 'leave' | 'drag' | 'drop', el: Component, infos: DropInfo ) => void;
+
+	type FilterCallback = ( el: Component ) => boolean;
+
+	 class DragManager  {
+		dragSource: Component;
+		dragGhost: HTMLElement;
+		dropTarget: Component;
+		notified: Component;
+		timer: any;
+		registerDraggableElement( el: Component ): void;
+		registerDropTarget( el: Component, cb: DropCallback, filterCB: FilterCallback ): void;
+		_startCheck(  ): void;
+		_check(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_router.ts
+
+	type RouteHandler = ( params: any, path: string ) => void;
+
+	interface Segment  {
+		keys: string[];
+		pattern: RegExp;
+	}
+
+	interface Route  {
+		keys: string[];
+		pattern: RegExp;
+		handler: RouteHandler;
+	}
+
+	interface RouterEvents extends EventMap {
+		error: EvError;
+	}
+
+	export class Router extends EventSource< RouterEvents > {
+		m_routes: Route[];
+		m_useHash: boolean;
+		constructor( useHash: any );
+		get( uri: string | RegExp, handler: RouteHandler ): void;
+		init(  ): void;
+		_getLocation(  ): void;
+		navigate( uri: string, notify: any, replace: any ): void;
+		_find( url: string ): { params: Record<string,any>, handlers: RouteHandler[] };
+	}
+
+	// ---------------------------------------
+	// from /src/core/core_svg.ts
+
+	 class SvgItem  {
+		_dom: SVGElement;
+		constructor( tag: string );
+		getDom(  ): void;
+		stroke( color: string, width: number ): this;
+		strokeWidth( width: number ): this;
+		strokeCap( cap: "butt" | "round" | "sqaure" ): void;
+		strokeOpacity( opacity: number ): void;
+		antiAlias( set: boolean ): void;
+		fill( color: string ): this;
+		no_fill(  ): this;
+		setAttr( name: string, value: string ): this;
+		setStyle<K extends keyof CSSStyleDeclaration>( name: K, value: string | number ): this;
+		addClass( cls: string ): void;
+		clip( id: string ): this;
+		transform( tr: string ): this;
+		rotate( deg: number, cx: number, cy: number ): this;
+		translate( dx: number, dy: number ): this;
+		scale( x: number ): this;
+		addDOMEvent<K extends keyof GlobalDOMEvents>( name: K, listener: GlobalDOMEvents[K], prepend: any ): void;
+	}
+
+	export class SvgPath extends SvgItem {
+		_path: string;
+		constructor(  );
+		_update(  ): this;
+		moveTo( x: number, y: number ): this;
+		lineTo( x: number, y: number ): this;
+		closePath(  ): this;
+		arc( x: number, y: number, r: number, start: number, end: number ): this;
+	}
+
+	export class SvgText extends SvgItem {
+		constructor( x: number, y: number, txt: string );
+		font( font: string ): this;
+		fontSize( size: number | string ): this;
+		fontWeight( weight: 'light' | 'normal' | 'bold' ): this;
+		textAlign( align: 'left' | 'center' | 'right' ): this;
+		verticalAlign( align: 'top' | 'center' | 'bottom' | 'baseline' ): this;
+	}
+
+	export class SvgShape extends SvgItem {
+		constructor( tag: string );
+	}
+
+	type number_or_perc = number | `${string}%`;
+
+	export class SvgGradient extends SvgItem {
+		g_id: any;
+		_id: string;
+		_stops: { offset: number_or_perc, color: string } [];
+		constructor( x1: number_or_perc, y1: number_or_perc, x2: number_or_perc, y2: number_or_perc );
+		addStop( offset: number_or_perc, color: string ): this;
+	}
+
+	export class SvgGroup extends SvgItem {
+		constructor( tag: any );
+		append<K extends SvgItem>( item: K ): K;
+		path(  ): SvgPath;
+		text( x: number, y: number, txt: string ): void;
+		ellipse( x: number, y: number, r1: number, r2: any ): SvgShape;
+		rect( x: number, y: number, w: number, h: number ): SvgShape;
+		group(  ): void;
+		linear_gradient( x1: number_or_perc, y1: number_or_perc, x2: number_or_perc, y2: number_or_perc ): void;
+		clear(  ): void;
+	}
+
+	export class SvgBuilder extends SvgGroup {
+		g_clip_id: any;
+		constructor(  );
+		addClip( x: number, y: number, w: number, h: number ): void;
+	}
+
+	interface SvgProps extends ComponentProps {
+		viewbox?: string;
+		svg?: SvgBuilder;
+	}
+
+	export class SvgComponent<P extends SvgProps = SvgProps> extends Component<P> {
+		constructor( props: P );
+	}
+
+	// ---------------------------------------
+	// from /src/components/boxes/boxes.ts
+
+	export interface BoxProps extends ComponentProps {
+	}
+
+	export class Box<P extends BoxProps=BoxProps, E extends ComponentEvents=ComponentEvents> extends Component<P,E> {
+	}
+
+	export class HBox<P extends BoxProps=BoxProps, E extends ComponentEvents=ComponentEvents> extends Box<P,E> {
+	}
+
+	export class VBox<P extends BoxProps=BoxProps, E extends ComponentEvents=ComponentEvents> extends Box<P,E> {
+		constructor( p: P );
+	}
+
+	interface StackItem  {
+		name: string;
+		content: Component;
+	}
+
+	interface StackedLayoutProps extends Omit<ComponentProps,"content"> {
+		default: string;
+		items: StackItem[];
+	}
+
+	interface _StackItem extends StackItem {
+		page: Component;
+	}
+
+	export class StackBox extends Box<StackedLayoutProps> {
+		_items: _StackItem[];
+		constructor( props: StackedLayoutProps );
+		select( name: string ): void;
+		_createPage( page: _StackItem ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/icon/icon.ts
+
+	type solveCallback = (data:string)=>void;
+
+	 class SvgLoader  {
+		cache: Map<string,string>;
+		waiters: Map<string,solveCallback[]>;
+		constructor(  );
+		load( file: string ): Promise<string>;
+		_load( file: string ): Promise<string>;
+	}
+
+	export interface IconProps extends ComponentProps {
+		iconId?: string;
+	}
+
+	export class Icon extends Component<IconProps> {
+		constructor( props: IconProps );
+		setIcon( iconId: string ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/button/button.ts
+
+	interface ButtonEvents extends ComponentEvents {
+		click: EvClick;
+	}
+
+	export interface ButtonProps extends ComponentProps {
+		label?: string;
+		icon?: string;
+		click?: EventCallback<EvClick>;
+	}
+
+	export class Button extends Component<ButtonProps,ButtonEvents> {
+		constructor( props: ButtonProps );
+		_on_click( ev: MouseEvent ): void;
+		setText( text: string | UnsafeHtml ): void;
+		setIcon( icon: string ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/label/label.ts
+
+	interface LabelProps extends ComponentProps {
+		text?: string | UnsafeHtml;
+		icon?: string;
+		labelFor?: string;
+	}
+
+	export class Label extends Component<LabelProps> {
+		constructor( p: LabelProps );
+		setText( text: string | UnsafeHtml ): void;
+		setIcon( icon: string ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/form/form.ts
+
+	type FormValue = string | number | boolean;
+
+	type FormValues = Record<string,FormValue>;
+
+	export class Form extends Box {
+		setValues( values: FormValues ): void;
+		getValues(  ): FormValues;
+	}
+
+	// ---------------------------------------
+	// from /src/components/sizers/sizer.ts
+
+	interface EvSizeChange extends ComponentEvent {
+		size: number;
+	}
+
+	interface CSizerEvent extends ComponentEvents {
+		resize: EvSizeChange;
+	}
+
+	export class CSizer extends Component<ComponentProps,CSizerEvent> {
+		_type: string;
+		_ref: Component;
+		_delta: Point;
+		constructor( type: string, target: Component );
+		_onMouseMove( e: PointerEvent ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/popup/popup.ts
+
+	export interface PopupEvents extends ComponentEvents {
+		closed: ComponentEvent;
+		opened: ComponentEvent;
+	}
+
+	export interface PopupProps extends ComponentProps {
+		modal?: boolean;
+		autoClose?: boolean | string;
+		sizable?: boolean;
+		movable?: boolean;
+	}
+
+	export class Popup<P extends PopupProps = PopupProps, E extends PopupEvents = PopupEvents> extends Component<P,E> {
+		_isopen: any;
+		_isshown: any;
+		constructor( props: P );
+		displayNear( rc: Rect, dst: any, src: any, offset: any ): void;
+		displayCenter(  ): void;
+		displayAt( x: number, y: number ): void;
+		_show(  ): void;
+		show( show: any ): void;
+		isOpen(  ): void;
+		close(  ): void;
+		_dismiss: any;
+		dismiss( after: any ): void;
+		_showModalMask(  ): void;
+		_updateModalMask(  ): void;
+		_createSizers(  ): void;
+	}
+
+	 class CMover  {
+		ref: Component;
+		delta: Point;
+		self: boolean;
+		constructor( x: Component, ref: Component );
+		_onMouseMove( e: PointerEvent ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/dialog/dialog.ts
+
+	export interface DialogProps extends PopupProps {
+		icon?: string;
+		title: string;
+		form: Form;
+		buttons: BtnGroupItem[];
+		closable?: boolean;
+	}
+
+	export interface EvBtnClick extends CoreEvent {
+		button: string;
+	}
+
+	interface DialogEvents extends PopupEvents {
+		btnclick: EvBtnClick;
+		close: ComponentEvent;
+	}
+
+	export class Dialog<P extends DialogProps = DialogProps, E extends DialogEvents = DialogEvents> extends Popup<P,E> {
+		constructor( props: P );
+		display(  ): void;
+		close(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/btngroup/btngroup.ts
+
+	type predefined = "ok" | "cancel" | "yes" | "no" | "retry" | "abort" | "-";
+
+	type BtnGroupItem = predefined | Button | Label;
+
+	interface BtnGroupEvents extends ComponentEvents {
+		btnclick: EvBtnClick;
+	}
+
+	interface BtnGroupProps extends Omit<ComponentProps,"content"> {
+		align?: "left" | "center" | "right";
+		vertical?: boolean;
+		items: BtnGroupItem[];
+		reverse?: boolean;
+		btnclick?: EventCallback<EvBtnClick>;
+	}
+
+	export class BtnGroup extends Box<BtnGroupProps,BtnGroupEvents> {
+		constructor( props: BtnGroupProps );
+		setButtons( btns: BtnGroupItem[] ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/menu/menu.ts
+
+	export interface MenuItem  {
+		cls?: string;
+		icon?: string;
+		text: string | UnsafeHtml;
+		menu?: Menu;
+		disabled?: true;
+		click?: DOMEventHandler;
+	}
+
+	type MenuElement = MenuItem | Component | string;
+
+	export interface MenuProps extends Omit<PopupProps,"content"> {
+		items: MenuElement[];
+	}
+
+	 class CMenuSep extends Component {
+		constructor(  );
+	}
+
+	 class CMenuItem extends Component {
+		menu: Menu;
+		constructor( itm: MenuItem );
+		dismiss( after: boolean ): void;
+		openSub( delayed: boolean ): void;
+		closeSub(  ): void;
+	}
+
+	export class Menu extends Popup {
+		constructor( props: MenuProps );
+	}
+
+	// ---------------------------------------
+	// from /src/components/calendar/calendar.ts
+
+	interface CalendarEventMap extends ComponentEvents {
+		change?: EvChange;
+	}
+
+	interface CalendarProps extends ComponentProps {
+		date?: Date;
+		minDate?: Date;
+		maxDate?: Date;
+		change?: EventCallback<EvChange>;
+	}
+
+	export class Calendar extends VBox<CalendarProps, CalendarEventMap> {
+		m_date: Date;
+		constructor( props: CalendarProps );
+		_update(  ): void;
+		select( date: Date ): void;
+		_next( n: boolean ): void;
+		_choose( type: 'month' | 'year' ): void;
+		getDate(  ): void;
+		setDate( date: Date ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/input/input.ts
+
+	export interface BaseProps extends ComponentProps {
+		name?: string;
+	}
+
+	interface CheckboxProps extends BaseProps {
+		type: "checkbox";
+		value?: boolean | number | string;
+		checked?: boolean;
+	}
+
+	interface RadioProps extends BaseProps {
+		type: "radio";
+		value: boolean | number | string;
+		checked?: boolean;
+	}
+
+	export interface RangeProps extends BaseProps {
+		type: "range";
+		value: number;
+		min: number;
+		max: number;
+		step?: number;
+	}
+
+	interface DateProps extends BaseProps {
+		type: "date";
+		readonly?: boolean;
+		required?: boolean;
+		value: Date | string;
+	}
+
+	interface NumberProps extends BaseProps {
+		type: "number";
+		readonly?: boolean;
+		required?: boolean;
+		value: number | string;
+		min?: number;
+		max?: number;
+		step?: number;
+	}
+
+	interface FileProps extends BaseProps {
+		type: "file";
+		accept: string | string[];
+	}
+
+	export interface TextInputProps extends BaseProps {
+		type: "text" | "email" | "password";
+		readonly?: boolean;
+		required?: boolean;
+		pattern?: string;
+		value: string | number;
+		placeholder?: string;
+		spellcheck?: boolean;
+	}
+
+	type InputProps = CheckboxProps | RadioProps | TextInputProps | RangeProps | DateProps | NumberProps | FileProps;
+
+	export class Input extends Component<InputProps> {
+		constructor( props: InputProps );
+		getValue(  ): void;
+		setValue( value: string ): void;
+		getNumValue(  ): void;
+		setNumValue( value: number ): void;
+		setReadOnly( ro: boolean ): void;
+		selectAll(  ): void;
+		select( start: number, length: number ): void;
+		getSelection(  ): void;
+		queryInterface<T extends IComponentInterface>( name: string ): T;
+	}
+
+	// ---------------------------------------
+	// from /src/components/checkbox/checkbox.ts
+
+	interface CheckBoxEvents extends ComponentEvents {
+		change?: EvChange;
+	}
+
+	interface CheckboxProps extends ComponentProps {
+		label: string;
+		checked?: boolean;
+		value?: boolean | number | string;
+		change?: EventCallback<EvChange>;
+	}
+
+	export class Checkbox extends Component<CheckboxProps,CheckBoxEvents> {
+		_input: Input;
+		constructor( props: CheckboxProps );
+		_on_change(  ): void;
+		getCheck(  ): void;
+		setCheck( ck: boolean ): void;
+		setLabel( text: string ): void;
+		toggle(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/colorinput/colorinput.ts
+
+	interface ColorInputProps extends BoxProps {
+		color: Color | string;
+	}
+
+	export class ColorInput extends HBox<ColorInputProps> {
+		constructor( props: ColorInputProps );
+	}
+
+	// ---------------------------------------
+	// from /src/components/colorpicker/colorpicker.ts
+
+	interface ColorPickerProps extends ComponentProps {
+		color: string | Color;
+	}
+
+	interface HueChangeEvent extends ComponentEvent {
+		hue: number;
+	}
+
+	interface AlphaChangeEvent extends ComponentEvent {
+		alpha: number;
+	}
+
+	interface SatChangeEvent extends ComponentEvent {
+		saturation: number;
+		value: number;
+	}
+
+	interface CommonEvents extends ComponentEvents {
+		hue_change: HueChangeEvent;
+		alpha_change: AlphaChangeEvent;
+		sat_change: SatChangeEvent;
+	}
+
+	export class Saturation extends Box<BoxProps,CommonEvents> {
+		mdown: any;
+		irect: Rect;
+		hsv: Hsv;
+		color: Component;
+		thumb: Component;
+		constructor( props: BoxProps, init: Hsv );
+		mousedown( ev: PointerEvent ): void;
+		mousemove( ev: PointerEvent ): void;
+		mouseup( ev: PointerEvent ): void;
+		updateThumbMarker(  ): void;
+		updateBaseColor( hsv: Hsv ): void;
+		move( sens: string, delta: number ): void;
+	}
+
+	 class HueSlider extends Box<BoxProps,CommonEvents> {
+		thumb: Component;
+		hsv: Hsv;
+		mdown: any;
+		irect: Rect;
+		constructor( props: BoxProps, init: Hsv );
+		mousedown( ev: PointerEvent ): void;
+		mousemove( ev: PointerEvent ): void;
+		mouseup( ev: PointerEvent ): void;
+		updateHue( hsv: Hsv ): void;
+		move( delta: number ): void;
+	}
+
+	 class AlphaSlider extends Box<BoxProps,CommonEvents> {
+		thumb: Component;
+		color: Component;
+		hsv: Hsv;
+		mdown: any;
+		irect: Rect;
+		constructor( props: BoxProps, init: Hsv );
+		_on_mousedown( ev: PointerEvent ): void;
+		_on_mousemove( ev: PointerEvent ): void;
+		_on_mouseup( ev: PointerEvent ): void;
+		updateAlpha(  ): void;
+		updateBaseColor( hsv: Hsv ): void;
+		setColor( hsv: Hsv ): void;
+		move( delta: number ): void;
+	}
+
+	interface ChangeEvent extends ComponentEvent {
+		color: Color;
+	}
+
+	interface ColorPickerChangeEvents extends ComponentEvents {
+		change: ChangeEvent;
+	}
+
+	export class ColorPicker extends VBox<ColorPickerProps,ColorPickerChangeEvents> {
+		_base: Color;
+		_sat: Saturation;
+		_swatch: Component;
+		_hue: HueSlider;
+		_alpha: AlphaSlider;
+		constructor( props: ColorPickerProps );
+		_onkey( ev: KeyboardEvent ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/viewport/viewport.ts
+
+	export class Viewport extends Component {
+		constructor( props: ComponentProps );
+	}
+
+	export class ScrollView extends Component {
+		constructor( props: ComponentProps );
+		getViewport(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/listbox/listbox.ts
+
+	enum kbNav {
+		first,
+		prev,
+		next,
+		last,
+	}
+
+	type ListboxID = number | string;
+
+	export interface ListItem  {
+		id: ListboxID;
+		text: string;
+		iconId?: string;
+		data?: any;
+		cls?: string;
+		checked?: boolean;
+	}
+
+	interface ListboxEvents extends ComponentEvents {
+		click?: EvClick;
+		dblClick?: EvDblClick;
+		contextMenu?: EvContextMenu;
+		selectionChange?: EvSelectionChange;
+	}
+
+	interface ListboxProps extends Omit<ComponentProps,'content'> {
+		items?: ListItem[];
+		renderer?: ( item: ListItem ) => Component;
+		checkable?: true;
+	}
+
+	export class Listbox extends Component<ListboxProps,ListboxEvents> {
+		_view: Viewport;
+		_selection: ListboxID;
+		_selitem: Component;
+		_items: ListItem[];
+		preventFocus: any;
+		constructor( props: ListboxProps );
+		_on_key( ev: KeyboardEvent ): void;
+		navigate( sens: kbNav ): void;
+		_on_click( ev: UIEvent ): void;
+		_on_ctx_menu( ev: MouseEvent ): void;
+		_selectItem( id: ListboxID, item: Component ): void;
+		_findItem( id: ListboxID ): void;
+		_findItemIndex( id: ListboxID ): void;
+		clearSelection(  ): void;
+		setItems( items: ListItem[] ): void;
+		renderItem( item: ListItem ): void;
+		defaultRenderer( item: ListItem ): Component;
+		filter( filter: string ): void;
+		appendItem( item: ListItem, prepend: any, select: any ): void;
+		updateItem( id: any, item: ListItem ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/combobox/combobox.ts
+
+	interface DropdownEvents extends PopupEvents {
+		selectionChange: EvSelectionChange;
+	}
+
+	interface DropdownProps extends Omit<PopupProps,"content"> {
+		items: ListItem[];
+	}
+
+	 class Dropdown extends Popup<DropdownProps,DropdownEvents> {
+		_list: Listbox;
+		constructor( props: DropdownProps, content: ListItem[] );
+		getList(  ): void;
+	}
+
+	interface ComboboxProps extends Omit<ComponentProps,"content"> {
+		label?: string;
+		labelWidth?: number | string;
+		readonly?: boolean;
+		items: ListItem[];
+	}
+
+	export class Combobox extends Component<ComboboxProps> {
+		_dropdown: Dropdown;
+		_label: Label;
+		_input: Input;
+		_button: Button;
+		_prevent_close: any;
+		_edit: HBox;
+		constructor( props: ComboboxProps );
+		_on_key( ev: KeyboardEvent ): void;
+		_on_input(  ): void;
+		_on_focusout(  ): void;
+		_on_click(  ): void;
+		showDropDown(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/header/header.ts
+
+	interface HeaderItem  {
+		name: string;
+		title: string;
+		iconId?: string;
+		width?: number;
+	}
+
+	interface HeaderProps extends Omit<ComponentProps,"content"> {
+		items: HeaderItem[];
+	}
+
+	export class Header extends HBox<HeaderProps> {
+		_els: Component[];
+		_vwp: Component;
+		constructor( props: HeaderProps );
+		_calc_sizes(  ): void;
+		_on_resize(  ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/image/image.ts
+
+	export interface ImageProps extends ComponentProps {
+		src: string;
+		fit?: "contain" | "cover" | "fill" | "scale-down";
+		position?: string;
+		lazy?: boolean;
+		alt?: string;
+		draggable?: boolean;
+	}
+
+	export class Image extends Component<ImageProps> {
+		_img: Component;
+		constructor( props: ImageProps );
+		setImage( src: string ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/messages/messages.ts
+
+	export interface MessageBoxProps extends DialogProps {
+		message: string;
+		click: (button: string) => void;
+	}
+
+	export class MessageBox extends Dialog<DialogProps> {
+		m_label: Label;
+		constructor( props: DialogProps );
+		setText( txt: string | UnsafeHtml ): void;
+		show( msg: string | UnsafeHtml ): MessageBox;
+	}
+
+	// ---------------------------------------
+	// from /src/components/notification/notification.ts
+
+	interface NotificationProps extends ComponentProps {
+		loading?: boolean;
+		iconId?: string;
+		closable?: boolean;
+		mode?: "success" | "danger";
+		title: string;
+		text: string | UnsafeHtml;
+	}
+
+	export class Notification extends Popup {
+		constructor( props: NotificationProps );
+		close(  ): void;
+		display( time_in_s: any ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/panel/panel.ts
+
+	interface PanelProps extends ComponentProps {
+		title: string;
+		icon?: string;
+		bodyModel?: Constructor<Component>;
+	}
+
+	export class Panel extends VBox<PanelProps> {
+		_title: Component;
+		_body: Component;
+		constructor( props: PanelProps );
+		setContent( content: ComponentContent ): void;
+		setTitle( title: string | UnsafeHtml ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/progress/progress.ts
+
+	interface ProgressProps extends ComponentProps {
+		value: number;
+		min: number;
+		max: number;
+	}
+
+	export class Progress extends Component<ProgressProps> {
+		_bar: Component;
+		constructor( props: ProgressProps );
+		setValue( value: number ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/rating/rating.ts
+
+	interface RatingEventMap extends ComponentEvents {
+		change: EvChange;
+	}
+
+	export interface RatingProps extends ComponentProps {
+		steps?: number;
+		value?: number;
+		icon?: string;
+		name?: string;
+		change?: EventCallback<EvChange>;
+	}
+
+	export class Rating extends HBox<RatingProps,RatingEventMap> {
+		m_els: Component[];
+		m_input: Input;
+		constructor( props: RatingProps );
+		_update(  ): void;
+		getValue(  ): void;
+		setValue( v: number ): void;
+		setSteps( n: number ): void;
+		setShape( icon: string ): void;
+		_on_click( ev: MouseEvent ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/slider/slider.ts
+
+	interface ChangeEvent extends ComponentEvent {
+		value: number;
+	}
+
+	interface SliderEvents extends ComponentEvents {
+		change: ChangeEvent;
+	}
+
+	interface SliderProps extends ComponentProps {
+		value: number;
+		min: number;
+		max: number;
+		step?: number;
+	}
+
+	export class Slider extends Component<SliderProps,SliderEvents> {
+		_mdown: any;
+		_irect: Rect;
+		_thumb: Component;
+		_bar: Component;
+		_range: Input;
+		constructor( props: SliderProps );
+		_on_mousedown( ev: PointerEvent ): void;
+		_on_mousemove( ev: PointerEvent ): void;
+		_update(  ): void;
+		_on_mouseup( ev: PointerEvent ): void;
+		_on_key( ev: KeyboardEvent ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/switch/switch.ts
+
+	interface SwitchProps extends ComponentProps {
+		label: string;
+		checked?: boolean;
+		value?: string;
+	}
+
+	export class Switch extends HBox<SwitchProps> {
+		constructor( props: SwitchProps );
+	}
+
+	// ---------------------------------------
+	// from /src/components/tabs/tabs.ts
+
+	export interface TabItem  {
+		name: string;
+		title: string;
+		icon?: string;
+		tab: Component;
+	}
+
+	 class CTab extends Button {
+		constructor( props: ButtonProps, item: TabItem );
+	}
+
+	interface TablistClickEvent extends CoreEvent {
+		name: string;
+	}
+
+	interface TablistProps extends ComponentProps {
+		click: ( ev: TablistClickEvent ) => void;
+	}
+
+	interface TablistEvents extends ComponentEvents {
+		click: TablistClickEvent;
+	}
+
+	 class CTabList extends HBox<TablistProps,TablistEvents> {
+		_selitem: Button;
+		_selection: string;
+		constructor( props: TablistProps, content: TabItem[] );
+		_on_click( ev: EvClick ): void;
+		select( name: string ): void;
+	}
+
+	interface TabsProps extends Omit<ComponentProps,"content"> {
+		default: string;
+		items: TabItem[];
+	}
+
+	export class Tabs extends VBox<TabsProps> {
+		_list: CTabList;
+		_stack: StackBox;
+		constructor( props: TabsProps );
+		selectTab( name: string ): void;
+		_onclick( ev: TablistClickEvent ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/textarea/textarea.ts
+
+	interface TextAreaProps extends BaseProps {
+		label?: string;
+		value?: string;
+		resize?: boolean;
+	}
+
+	export class TextArea extends VBox {
+		_input: Component;
+		constructor( props: TextAreaProps );
+	}
+
+	// ---------------------------------------
+	// from /src/components/textedit/textedit.ts
+
+	interface TextEditProps extends ComponentProps {
+		label: string | UnsafeHtml;
+		labelWidth?: number;
+		inputId?: string;
+		type?: "text" | "email" | "password";
+		readonly?: boolean;
+		required?: boolean;
+		value: string | number;
+		placeholder?: string;
+		inputGadgets?: Component[];
+	}
+
+	export class TextEdit extends HBox {
+		constructor( props: TextEditProps );
+	}
+
+	// ---------------------------------------
+	// from /src/components/tooltips/tooltips.ts
+
+	 class Tooltip extends Popup {
+		constructor( props: PopupProps );
+		setText( text: string|UnsafeHtml ): void;
+	}
+
+	// ---------------------------------------
+	// from /src/components/treeview/treeview.ts
+
+	enum kbTreeNav {
+		first,
+		prev,
+		next,
+		last,
+		parent,
+		child,
+		expand,
+		collapse,
+		toggle,
+	}
+
+	export interface TreeItem extends ListItem {
+		children?: TreeItem[];
+		open?: boolean;
+	}
+
+	interface TreeviewProps extends Omit<ComponentProps,"content"> {
+		items: TreeItem[];
+	}
+
+	interface ChangeEvent extends ComponentEvent {
+		selection: TreeItem;
+	}
+
+	interface TreeviewEvents extends ComponentEvents {
+		change: ChangeEvent;
+	}
+
+	 class CTreeViewItem extends Box {
+		_item: TreeItem;
+		_label: Component;
+		_icon: Icon;
+		_childs: Component;
+		constructor( props: BoxProps, item: TreeItem );
+		toggle( ev: UIEvent ): void;
+		open( open: any ): void;
+		setItems( items: TreeItem[ ] ): void;
+	}
+
+	export class Treeview extends Component<TreeviewProps,TreeviewEvents> {
+		_selection: ListboxID;
+		_selitem: Component;
+		_items: TreeItem[];
+		constructor( props: TreeviewProps );
+		setItems( items: TreeItem[ ] ): void;
+		_onclick( ev: UIEvent ): void;
+		_onkey( ev: KeyboardEvent ): void;
+		navigate( sens: kbTreeNav ): void;
+		_flattenOpenItems(  ): void;
+		_flattenItems(  ): void;
+		_selectItem( id: ListboxID, item: Component ): void;
+		_findItem( id: ListboxID ): void;
+		clearSelection(  ): void;
+	}
+
+}
+