xmlui 0.9.32 → 0.9.34

package/dist/standalone/xmlui-standalone.es.d.ts

@@ -1,3 +1,2421 @@
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { default as default_3 } from 'react/jsx-runtime';
+import { DefaultToastOptions } from 'react-hot-toast';
+import { ErrorInfo } from 'react';
+import { ForwardedRef } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { NavigateOptions } from 'react-router-dom';
+import { QueryClient } from '@tanstack/react-query';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { RefObject } from 'react';
+import { Renderable } from 'react-hot-toast';
+import { Root } from 'react-dom/client';
+import { SetupWorker } from 'msw/browser';
+import { To } from 'react-router-dom';
+import { Toast } from 'react-hot-toast';
+import { ToastOptions } from 'react-hot-toast';
+import { ValueOrFunction } from 'react-hot-toast';
+
+/**
+ * This type represents the context in which an action is executed.
+ */
+declare interface ActionExecutionContext {
+    /**
+     * A unique identifier for the container that the action is executed in.
+     */
+    uid: symbol;
+    /**
+     * The state of the container that the action is executed in.
+     */
+    state: ContainerState;
+    getCurrentState: () => ContainerState;
+    /**
+     * The appContext object passed to the current app
+     */
+    appContext: AppContextObject;
+    /**
+     * The lookup function to resolve a sync action by its name.
+     */
+    lookupAction: LookupAsyncFnInner;
+    navigate: any;
+    location: any;
+}
+
+/**
+ * This type represents a function that executes a particular action within the specified context
+ * using the given arguments.
+ */
+declare type ActionFunction = (executionContext: ActionExecutionContext, ...args: any[]) => any;
+
+declare type AlignmentOptions = (typeof alignmentOptionValues)[number];
+
+declare const alignmentOptionValues: readonly ["start", "center", "end"];
+
+declare namespace all {
+    export {
+        ThemeDefinition,
+        ComponentDef,
+        ComponentRendererDef,
+        CompoundComponentDef,
+        ComponentLike,
+        StandaloneAppDescription,
+        StandaloneJsonConfig,
+        ApiInterceptorDefinition,
+        RegisterComponentApiFn,
+        TreeNode,
+        RendererContext,
+        ComponentMetadata,
+        ThemeTone,
+        XmlUiNode,
+        StandaloneApp,
+        StandaloneExtensionManager,
+        createComponentRenderer,
+        createMetadata,
+        d,
+        parseScssVar,
+        startApp,
+        useTheme,
+        AppRoot,
+        ErrorBoundary,
+        Icon,
+        Stack,
+        Button,
+        Splitter,
+        getColor,
+        TabItemComponent as TabItem,
+        Tabs,
+        useColors,
+        toCssVar,
+        useDevTools,
+        useLogger,
+        errReportComponent,
+        xmlUiMarkupToComponent,
+        ApiInterceptorProvider,
+        Spinner,
+        builtInThemes,
+        XmlUiHelper,
+        Text_2 as Text,
+        NestedApp
+    }
+}
+
+declare type ApiInterceptorDefinition = {
+    type?: string;
+    config?: Record<string, any>;
+    schemaDescriptor?: SchemaDescriptor;
+    apiUrl?: string;
+    initialData?: Record<string, any[]> | (() => Promise<Record<string, any[]>>);
+    helpers?: Record<string, any>;
+    initialize?: string;
+    operations?: Record<string, InterceptorOperationDef>;
+    auth?: AuthDefinition;
+};
+
+declare function ApiInterceptorProvider({ interceptor, children, apiWorker, useHashBasedRouting, }: {
+    interceptor?: ApiInterceptorDefinition;
+    children: ReactNode;
+    apiWorker?: SetupWorker;
+    useHashBasedRouting?: boolean;
+}): JSX_2.Element;
+
+/**
+ * This interface defines the properties and services of an app context that the application components can use when
+ * implementing their behavior.
+ */
+declare type AppContextObject = {
+    /**
+     * Accept other methods
+     */
+    [x: string]: unknown;
+    version: string;
+    Actions: Record<string, ActionFunction>;
+    /* Excluded from this release type: apiInterceptorContext */
+    /**
+     * This property returns a hash object containing all application-global settings
+     * defined in the app's configuration file.
+     */
+    appGlobals?: Record<string, any>;
+    /* Excluded from this release type: debugEnabled */
+    /* Excluded from this release type: decorateComponentsWithTestId */
+    /**
+     * This property returns an object with some properties of the current environment.
+     */
+    environment: {
+        isWindowFocused: boolean;
+    };
+    /**
+     * This property returns an object with information about the current media size.
+     */
+    mediaSize: MediaSize;
+    /* Excluded from this release type: queryClient */
+    /**
+     * This property returns `true` if the app is a standalone XMLUI app; otherwise
+     * (for example, as part of a website), it returns `false`.
+     */
+    standalone?: boolean;
+    /**
+     * This function formats the specified value's date part into a local date string
+     * (according to the machine's local settings).
+     * @param date Date to format
+     */
+    formatDate: (date: string | Date) => string | undefined;
+    /**
+     * This function formats the specified value into a local
+     * date and time string (according to the machine's local settings).
+     * @param date Date to format
+     */
+    formatDateTime: (date: any) => string | undefined;
+    /**
+     * This function formats the specified value's date part (without year)
+     * into a local date string (according to the machine's local settings).
+     * @param date Date to format
+     */
+    formatDateWithoutYear: (date: string | Date) => string | undefined;
+    /**
+     * This function formats the specified value's time part into a local date
+     * string (according to the machine's local settings).
+     * @param date Date to format
+     */
+    formatTime: (date: any) => string | undefined;
+    /**
+     * This function formats the specified value's time part (without seconds)
+     * into a local date string (according to the machine's local settings).
+     * @param date Date to format
+     */
+    formatTimeWithoutSeconds: (date: string | Date) => string | undefined;
+    /**
+     * This function creates a date from the specified input value. If no input
+     *  is provided, it returns the current date and time.
+     */
+    getDate: (date?: string | number | Date) => Date;
+    /**
+     * This function calculates the difference between the current date and the
+     * provided one and returns it in a human-readable form, such as "1 month", "2 weeks", etc.
+     * @param date
+     * @param nowLabel
+     * @param time
+     * @returns
+     */
+    getDateUntilNow: (date?: string | number | Date, nowLabel?: string, time?: string) => string;
+    /**
+     * This function converts the input string into a date value and returns
+     * the ISO 8601 string representation of the date. It can pass dates between
+     * the UI and backend APIs in a standard format.
+     * @param date Date to format
+     */
+    isoDateString: (date?: string) => string;
+    /**
+     * This function checks if the specified date is today.
+     * @param date Date to check
+     */
+    isToday: (date: string | Date) => boolean;
+    /**
+     * This function checks if the specified date is tomorrow.
+     * @param date Date to check
+     */
+    isTomorrow: (date: string | Date) => boolean;
+    /**
+     * This function checks if the specified date is yesterday.
+     * @param date Date to check
+     */
+    isYesterday: (date: string | Date) => boolean;
+    /**
+     * This function checks the date value provided for some particular
+     * values and returns accordingly. Otherwise, returns it as `formatDate` would.
+     * @param date Date to format
+     */
+    smartFormatDate: (date?: string | number | Date) => string;
+    /**
+     * This function checks the date value provided for some particular values and
+     * returns accordingly. Otherwise, returns it as `formatDateTime` would.
+     * @param date Date to format
+     */
+    smartFormatDateTime: (date: string | Date) => string | undefined;
+    /**
+     * This functions creates the difference between two dates in minutes.
+     * @param date1 First date
+     * @param date2 Second date
+     * @returns The difference in minutes
+     */
+    differenceInMinutes: (date1: number | Date, date2: number | Date) => number;
+    /**
+     * This function checks if the specified dates are on the same day.
+     * @param dateLeft First date
+     * @param dateRight Second Date
+     * @returns True, if the dates are on the same day; otherwise, false.
+     */
+    isSameDay: (dateLeft: number | Date, dateRight: number | Date) => boolean;
+    /**
+     * This function checks if the specified date is in the current calendar year.
+     * @param date Date to check
+     * @returns True, if the date is in the current year; otherwise, false.
+     */
+    isThisYear: (date: Date | number) => boolean;
+    /**
+     * This function calculates the average of the specified values and returns it.
+     * @param values Values to calculate the average
+     * @param decimals Number of decimal places to round the result
+     */
+    avg: (values: number[], decimals?: number) => number;
+    /**
+     * This function calculates the sum of the specified values and returns it.
+     * @param values Values to calculate the sum
+     */
+    sum: (values: number[]) => number;
+    /**
+     * This function returns the specified file size in a compact form, such as
+     * "112 B", "2.0 KiB", "23.4 KiB", "2.3 MiB", etc.
+     * @param bytes Number of bytes to format
+     */
+    formatFileSizeInBytes: (bytes: number) => string | undefined;
+    /**
+     * This function returns the type of the specified file.
+     * @param fileName Filename to check for extension
+     */
+    getFileExtension: (fileName: string) => string | undefined;
+    /**
+     * This function navigates to the specified `url`.
+     * @param url New app location
+     * @param options Navigation options
+     */
+    navigate: (url: To, options?: NavigateOptions) => void;
+    /**
+     * This property determines the base name used for the router.
+     */
+    routerBaseName: string;
+    /**
+     * Instructs the browser to display a dialog with an optional message, and to wait until the
+     * user either confirms or cancels the dialog. It returns a boolean indicating whether OK
+     * (`true`) or Cancel (`false`) was selected.
+     * @param title Dialog title
+     * @param message Confirmation message
+     * @param actionLabel Optional action label
+     * @return True, if the user confirmed the action; otherwise, false.
+     */
+    confirm: (title: string, message?: string, actionLabel?: string) => Promise<boolean>;
+    /**
+     * This method displays the specified `error` (error message) on the UI.
+     * @param error Error to display
+     */
+    signError(error: Error | string): void;
+    /**
+     * The toast service that displays messages in the UI.
+     */
+    toast: {
+        (message: Message, opts?: ToastOptions): string;
+        error: ToastHandler;
+        success: ToastHandler;
+        loading: ToastHandler;
+        custom: ToastHandler;
+        dismiss(toastId?: string): void;
+        remove(toastId?: string): void;
+        promise<T>(promise: Promise<T>, msgs: {
+            loading: Renderable;
+            success: ValueOrFunction<Renderable, T>;
+            error: ValueOrFunction<Renderable, any>;
+        }, opts?: DefaultToastOptions): Promise<T>;
+    };
+    /**
+     * This property returns the ID of the currently active theme.
+     */
+    activeThemeId: string;
+    /**
+     * This property returns the tone of the currently active theme ("light" or "dark").
+     */
+    activeThemeTone: "light" | "dark";
+    /**
+     * This property returns an array of all available theme IDs.
+     */
+    availableThemeIds: string[];
+    /**
+     * This function sets the current theme to the one with the specified `themeId`.
+     * @param themId New theme to set
+     */
+    setTheme: (themId: string) => void;
+    /**
+     * This function sets the current theme tone to the specified `tone` value ("light" or "dark").
+     * @param newTone New tone to set
+     */
+    setThemeTone: (newTone: "light" | "dark") => void;
+    /**
+     * This function toggles the current theme tone from "light" to "dark" or vice versa.
+     */
+    toggleThemeTone: () => void;
+    /**
+     * This property gets the information about the logged-in user. If `null`, no user is
+     * logged in. The user information may have any value; the app must be able to leverage
+     * this information.
+     */
+    loggedInUser: LoggedInUserDto | null;
+    /**
+     * This function sets the information about the logged-in user. The user information
+     * may have any value; the app must be able to leverage this information.
+     * @param loggedInUser Logged-in user information
+     */
+    setLoggedInUser: (loggedInUser: any) => void;
+    readonly resources?: Record<string, string>;
+    capitalize: (s?: string) => string;
+    pluralize: (number: number, singular: string, plural: string) => string;
+    delay: (timeInMs: number, callback?: any) => Promise<void>;
+    toHashObject: (arr: any[], keyProp: string, valueProp: string) => any;
+    findByField: (arr: any[], field: string, value: any) => any;
+    readonly embed: {
+        isInIFrame: boolean;
+    };
+    distinct: (arr: any[]) => any[];
+    forceRefreshAnchorScroll: () => void;
+};
+
+/**
+ * This component is responsible for running a pre-compiled xmlui app. It
+ * receives the internal representation of the app markup and code (coming
+ * from either code-behind files or inlined markup expressions) and executes
+ * the app accordingly.
+ */
+declare function AppRoot({ apiInterceptor, contributes, node, decorateComponentsWithTestId, debugEnabled, defaultTheme, defaultTone, resources, globalProps, standalone, trackContainerHeight, routerBaseName, previewMode, resourceMap, sources, extensionManager, children, projectCompilation, }: AppWrapperProps & {
+    extensionManager?: StandaloneExtensionManager;
+}): JSX_2.Element;
+
+declare type AppWrapperProps = {
+    node: ComponentLike;
+    previewMode?: boolean;
+    routerBaseName?: string;
+    contributes?: ContributesDefinition;
+    globalProps?: GlobalProps;
+    resources?: Record<string, string>;
+    standalone?: boolean;
+    trackContainerHeight?: TrackContainerHeight;
+    decorateComponentsWithTestId?: boolean;
+    debugEnabled?: boolean;
+    apiInterceptor?: ApiInterceptorDefinition;
+    defaultTheme?: string;
+    defaultTone?: ThemeTone;
+    resourceMap?: Record<string, string>;
+    sources?: Record<string, string>;
+    projectCompilation?: ProjectCompilation;
+    children?: ReactNode;
+};
+
+declare type ARRAY_DESTRUCTURE = typeof T_ARRAY_DESTRUCTURE;
+
+declare type ARRAY_LITERAL = typeof T_ARRAY_LITERAL;
+
+declare interface ArrayDestructure extends DestructureBase {
+    type: ARRAY_DESTRUCTURE;
+}
+
+declare interface ArrayLiteral extends ExpressionBase {
+    type: ARRAY_LITERAL;
+    items: Expression[];
+    loose?: boolean;
+}
+
+declare type ARROW_EXPRESSION = typeof T_ARROW_EXPRESSION;
+
+declare type ARROW_EXPRESSION_STATEMENT = typeof T_ARROW_EXPRESSION_STATEMENT;
+
+declare interface ArrowExpression extends ExpressionBase {
+    type: ARROW_EXPRESSION;
+    name?: string;
+    args: Expression[];
+    statement: Statement;
+}
+
+declare interface ArrowExpressionStatement extends ScripNodeBase {
+    type: ARROW_EXPRESSION_STATEMENT;
+    expr: ArrowExpression;
+}
+
+declare type ASSIGNMENT_EXPRESSION = typeof T_ASSIGNMENT_EXPRESSION;
+
+declare interface AssignmentExpression extends ExpressionBase {
+    type: ASSIGNMENT_EXPRESSION;
+    leftValue: Expression;
+    op: AssignmentSymbols;
+    expr: Expression;
+}
+
+declare type AssignmentSymbols = "=" | "+=" | "-=" | "**=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|=" | "&&=" | "||=" | "??=";
+
+/**
+ * XMLUI executes its code asynchronously. This type defines functions that can be used in XMLUI
+ * as actions or event handlers.
+ */
+declare type AsyncFunction = (...args: any) => Promise<any> | any;
+
+declare type AuthDefinition = {
+    defaultLoggedInUser?: any;
+};
+
+declare type BINARY_EXPRESSION = typeof T_BINARY_EXPRESSION;
+
+declare interface BinaryExpression extends ExpressionBase {
+    type: BINARY_EXPRESSION;
+    op: BinaryOpSymbols;
+    left: Expression;
+    right: Expression;
+}
+
+declare type BinaryOpSymbols = "**" | "*" | "/" | "%" | "+" | "-" | "<<" | ">>" | ">>>" | "<" | "<=" | ">" | ">=" | "==" | "===" | "!=" | "!==" | "&" | "|" | "^" | "&&" | "||" | "??" | "in";
+
+declare type BLOCK_STATEMENT = typeof T_BLOCK_STATEMENT;
+
+declare interface BlockStatement extends ScripNodeBase {
+    type: BLOCK_STATEMENT;
+    stmts: Statement[];
+}
+
+declare type BREAK_STATEMENT = typeof T_BREAK_STATEMENT;
+
+declare interface BreakStatement extends ScripNodeBase {
+    type: BREAK_STATEMENT;
+}
+
+declare const builtInThemes: Array<ThemeDefinition>;
+
+declare const Button: default_2.ForwardRefExoticComponent<{
+    id?: string;
+    type?: ButtonType;
+    variant?: ButtonVariant;
+    themeColor?: ButtonThemeColor;
+    size?: ComponentSize;
+    disabled?: boolean;
+    children?: default_2.ReactNode | default_2.ReactNode[];
+    icon?: default_2.ReactNode;
+    iconPosition?: IconPosition;
+    contentPosition?: AlignmentOptions;
+    orientation?: OrientationOptions;
+    formId?: string;
+    style?: CSSProperties;
+    gap?: string | number;
+    accessibilityProps?: any;
+    autoFocus?: boolean;
+    contextualLabel?: string;
+} & Pick<default_2.HTMLAttributes<HTMLButtonElement>, "className" | "aria-disabled" | "aria-label" | "aria-controls" | "aria-expanded" | "onClick" | "onFocus" | "onBlur" | "tabIndex" | "onMouseEnter" | "onMouseLeave"> & default_2.RefAttributes<HTMLButtonElement>>;
+
+declare type ButtonThemeColor = (typeof buttonThemeValues)[number];
+
+declare const buttonThemeValues: readonly ["attention", "primary", "secondary"];
+
+declare type ButtonType = (typeof buttonTypeValues)[number];
+
+declare const buttonTypeValues: readonly ["button", "submit", "reset"];
+
+declare type ButtonVariant = (typeof buttonVariantValues)[number];
+
+declare const buttonVariantValues: readonly ["solid", "outlined", "ghost"];
+
+declare type CALCULATED_MEMBER_ACCESS_EXPRESSION = typeof T_CALCULATED_MEMBER_ACCESS_EXPRESSION;
+
+declare interface CalculatedMemberAccessExpression extends ExpressionBase {
+    type: CALCULATED_MEMBER_ACCESS_EXPRESSION;
+    obj: Expression;
+    member: Expression;
+}
+
+declare type CodeDeclaration = {
+    source?: string;
+    tree: Expression;
+    [x: string]: unknown;
+};
+
+declare type CollectedDeclarations = {
+    vars: Record<string, CodeDeclaration>;
+    functions: Record<string, CodeDeclaration>;
+    moduleErrors?: ModuleErrors;
+};
+
+declare type ColorDef = {
+    name: string;
+    format: "hex" | "rgb" | "hsl";
+};
+
+declare type CompilationUnit = {
+    /** The file name */
+    filename: string;
+    /** Optional markup source (used in dev mode) */
+    markupSource?: string;
+    /** Optional code behind source (used in dev mode) */
+    codeBehindSource?: string;
+    /** Other (non-core) component names this component depends on */
+    dependencies: Set<string>;
+};
+
+/**
+ * Components can provide an API that other components can invoke (using
+ * the host component ID). This type defines the shape of a hash object that
+ * stores the API endpoints.
+ */
+declare type ComponentApi = Record<string, ((...args: any[]) => any) | boolean>;
+
+declare type ComponentCompilation = CompilationUnit & {
+    /** The compiled markup of the component file */
+    definition: CompoundComponentDef;
+};
+
+/**
+ * This interface represents the properties of a component definition.
+ */
+declare interface ComponentDef<TMd extends ComponentMetadata = ComponentMetadata> extends ComponentDefCore, Scriptable {
+    props?: Record<keyof TMd["props"], any>;
+    events?: Record<keyof TMd["events"], any>;
+    /**
+     * Components may have an API that other components can use to interact with them. This property holds
+     * the API methods associated with this component definition.
+     */
+    api?: Record<keyof TMd["apis"], any>;
+    /**
+     * Components may provide context variables that can be used to in expressions and event handlers
+     * within the component.
+     * REVIEW: This property can be removed after migration to the new componend definition type.
+     */
+    contextVars?: Record<keyof TMd["contextVars"], string>;
+}
+
+/**
+ * This interface represents the core properties of a component definition (independent
+ * of component metadata).
+ */
+declare interface ComponentDefCore {
+    type: string;
+    uid?: string;
+    testId?: string;
+    /**
+     * A component can define namespaces on it, with the <ComponentName xmlns:KEY="VALUE" /> syntax
+     * these are used later to resolve the `type` of the componentDef.
+     * <KEY:Button/> will have type `VALUE.Button` (joined with a "." (dot) )
+     */
+    namespaces?: Record<string, string>;
+    /**
+     * Though components manage their state internally, the app logic may require user state management.
+     * Components may have user *variables*, which the UI logic uses to manage the application state.
+     * This property holds the variables (name and value pairs) associated with this component definition.
+     */
+    vars?: Record<string, any>;
+    /**
+     * Each component may have child components to constitute a hierarchy of components. This property
+     * holds the definition of these nested children.
+     */
+    children?: ComponentDef[];
+    /**
+     * Components may have slots that can be filled with other components. This property holds the
+     * contents of the slots
+     */
+    slots?: Record<string, ComponentDef[]>;
+    /**
+     * This property is evaluated to a Boolean value during run time. When this value is `true`, the
+     * component with its children chain is rendered; otherwise, the entire component hierarchy is omitted
+     * from the rendered tree.
+     */
+    when?: string | boolean;
+    /**
+     * Some components work with data obtained asynchronously. Fetching this data requires some state
+     * management handling the complexity (including error handling) of data access. A *loader* is
+     * responsible for managing this logic. This property holds the loaders associated with this component
+     * definition.
+     */
+    loaders?: ComponentDef[];
+    /**
+     * Components may have functions that are used to perform some logic. This property holds the functions
+     * (name and function body) associated with this component definition.
+     */
+    functions?: Record<string, any>;
+    /**
+     * Components managing state through variables or loaders are wrapped with containers responsible
+     * for this job. Just as components, containers form a hierarchy. While working with this hierarchy,
+     * parent components may flow state values (key and value pairs) to their child containers. This
+     * property holds the name of state values to flow down to the direct child containers.
+     */
+    uses?: string[];
+    /**
+     * Arbitrary debug information that can be attached to a component definition.
+     * Current usage:
+     * - `debug: { source: { start: number, end: number } }` Ther start and end positions of of the source
+     *   belonging to the particular component definition.
+     */
+    debug?: Record<string, any>;
+}
+
+declare type ComponentExtension = ComponentRendererDef | CompoundComponentDef;
+
+/**
+ * Sometimes, components and compound components can both be used
+ */
+declare type ComponentLike = ComponentDef | CompoundComponentDef;
+
+/**
+ * Components have metadata that the rendering engine uses to render the
+ * component. This type defines the structure of such metadata.
+ *
+ * The type has generic parameters to ensure that type-checking works with
+ * the metadata defined here in concert with the renderer object using the
+ * same metadata type.
+ */
+declare type ComponentMetadata<TProps extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TEvents extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TContextValues extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TApis extends Record<string, ComponentPropertyMetadata> = Record<string, any>> = {
+    status?: "stable" | "experimental" | "deprecated" | "in progress";
+    description?: string;
+    shortDescription?: string;
+    props?: TProps;
+    events?: TEvents;
+    contextVars?: TContextValues;
+    apis?: TApis;
+    nonVisual?: boolean;
+    childrenAsTemplate?: string;
+    opaque?: boolean;
+    themeVars?: Array<string>;
+    themeVarDescriptions?: Record<string, string>;
+    defaultThemeVars?: DefaultThemeVars;
+    toneSpecificThemeVars?: Record<string, Record<string, string>>;
+    allowArbitraryProps?: boolean;
+    specializedFrom?: string;
+    docFolder?: string;
+    isHtmlTag?: boolean;
+};
+
+/**
+ * Components have properties, events, context values, and exposed API
+ * endpoints, each holding metadata the rendering engine uses at run time.
+ * This type defines the structure of such metadata.
+ */
+declare type ComponentPropertyMetadata = {
+    /**
+     * This field defines the description explaining the property. You can use
+     * markdown, as the UI may display this value.
+     */
+    readonly description: string;
+    /**
+     * This field defines the type of the property. The rendering engine uses this
+     * information to validate the property value.
+     */
+    readonly valueType?: PropertyValueType;
+    /**
+     * This field defines the available values of the property. The rendering engine
+     * uses this information to validate the property value.
+     */
+    readonly availableValues?: readonly PropertyValueDescription[];
+    /**
+     * This field defines the default value of the property. The rendering engine uses
+     * this information to set the default value of the property.
+     */
+    defaultValue?: any;
+    /**
+     * This field defines a validation function that the rendering engine uses to validate
+     * the property value. The function returns one or more hinst if the property value is
+     * invalid.
+     */
+    isValid?: IsValidFunction<any>;
+    /**
+     * Indicates that a particular property is internal and should not be exposed in the
+     * documentation
+     */
+    isInternal?: boolean;
+    /**
+     * Indicates that a particular property is required for the component to essentially function.
+     */
+    isRequired?: boolean;
+};
+
+declare interface ComponentRendererContextBase<TMd extends ComponentMetadata = ComponentMetadata> {
+    node: ComponentDef<TMd>;
+    state: ContainerState;
+    appContext?: AppContextObject;
+    renderChild: RenderChildFn;
+    layoutContext?: LayoutContext;
+}
+
+/**
+ * Components must be registered with a component registry so the engine can use them. This type
+ * collects the information held by the registry.
+ */
+declare type ComponentRendererDef<T extends ComponentDef = any> = {
+    /**
+     * The component's type identifier. In the markup, the component must use this name to be recognized.
+     */
+    type: string;
+    /**
+     * This function renders the component from its definition to its React representation.
+     */
+    renderer: ComponentRendererFn<T>;
+    /**
+     * The metadata to use when rendering the component
+     */
+    metadata?: ComponentMetadata;
+};
+
+/**
+ * This function renders a component definition into a React component
+ */
+declare type ComponentRendererFn<T extends ComponentDef> = (context: RendererContext<T>) => ReactNode;
+
+declare type ComponentSize = (typeof sizeValues)[number];
+
+/**
+ * XMLUI allows the creation of reusable components assembled from other XMLUI components (with markup).
+ * This type represents such components. The name `CompoundComponent` refers to the assembled nature
+ * of reusable components.
+ */
+declare interface CompoundComponentDef extends Scriptable {
+    /**
+     * Each compound component must have a unique name. The markup uses this name to refer to the
+     * particular compound component.
+     */
+    name: string;
+    /**
+     * Each compound component must have a single root component defining the component contents.
+     */
+    component: ComponentDef;
+    /**
+     * Compound components may provide an API that other components can use to interact with them. This
+     * property holds the API methods associated with this compound component definition.
+     */
+    api?: Record<string, any>;
+    /**
+     * This property holds the variables (name and value pairs) associated with this compound component
+     * definition.
+     */
+    vars?: Record<string, any>;
+    /**
+     * A component can define namespaces on it, with the <ComponentName xmlns:KEY="VALUE" /> syntax
+     * these are used later to resolve the `type` of the componentDef.
+     * <KEY:Button/> will have type `VALUE.Button` (joined with a "." (dot) )
+     */
+    namespaces?: Record<string, string>;
+    /**
+     * Arbitrary debug information that can be attached to a component definition.
+     * Current usage:
+     * - `debug: { source: { start: number, end: number } }` Ther start and end positions of of the source
+     *   belonging to the particular component definition.
+     */
+    debug?: Record<string, any>;
+}
+
+declare type CONDITIONAL_EXPRESSION = typeof T_CONDITIONAL_EXPRESSION;
+
+declare interface ConditionalExpression extends ExpressionBase {
+    type: CONDITIONAL_EXPRESSION;
+    cond: Expression;
+    thenE: Expression;
+    elseE: Expression;
+}
+
+declare type CONST_STATEMENT = typeof T_CONST_STATEMENT;
+
+declare interface ConstStatement extends ScripNodeBase {
+    type: CONST_STATEMENT;
+    decls: VarDeclaration[];
+}
+
+/**
+ * We store the state application state in a hierarchical structure of containers. This type represents
+ * the state within a single container stored as key and value pairs.
+ */
+declare type ContainerState = Record<string | symbol, any>;
+
+declare type CONTINUE_STATEMENT = typeof T_CONTINUE_STATEMENT;
+
+declare interface ContinueStatement extends ScripNodeBase {
+    type: CONTINUE_STATEMENT;
+}
+
+/**
+ * Applications can contribute to the registry with their custom (third-party)
+ * and application-specific components and others. This type holds the
+ * definitions of these extra artifacts.
+ */
+declare type ContributesDefinition = {
+    /**
+     * Native xmlui components that come with the app.
+     */
+    components?: ComponentRendererDef[];
+    /**
+     * Application-specific compound components that come with the app.
+     */
+    compoundComponents?: CompoundComponentDef[];
+    /**
+     * Themes that come with the app.
+     */
+    themes?: ThemeDefinition[];
+};
+
+/**
+ * This helper function creates a component renderer definition from its arguments.
+ * @param type The unique identifier of the component definition
+ * @param renderer The function that renders the component definition into a React node
+ * @param metadata Optional hints to help fix the rendering errors coming from invalid component property definitions
+ * @returns The view renderer definition composed of the arguments
+ */
+declare function createComponentRenderer<TMd extends ComponentMetadata>(type: string, metadata: TMd, renderer: ComponentRendererFn<ComponentDef<TMd>>): ComponentRendererDef;
+
+declare function createMetadata<TProps extends Record<string, ComponentPropertyMetadata>, TEvents extends Record<string, ComponentPropertyMetadata>, TContextVars extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TApis extends Record<string, ComponentPropertyMetadata> = Record<string, any>>(metadata: ComponentMetadata<TProps, TEvents, TContextVars, TApis>): ComponentMetadata<TProps, TEvents, TContextVars, TApis>;
+
+declare function d(description: string, availableValues?: readonly PropertyValueDescription[], valueType?: PropertyValueType, defaultValue?: any, isValid?: IsValidFunction<any>, isRequired?: boolean): ComponentPropertyMetadata;
+
+declare const _default: {
+    standalone: StandaloneExtensionManager;
+    StandaloneApp: typeof all.StandaloneApp;
+    StandaloneExtensionManager: typeof StandaloneExtensionManager;
+    createComponentRenderer: typeof all.createComponentRenderer;
+    createMetadata: typeof all.createMetadata;
+    d: typeof all.d;
+    parseScssVar: typeof all.parseScssVar;
+    startApp: typeof startApp;
+    useTheme: typeof all.useTheme;
+    AppRoot: typeof all.AppRoot;
+    ErrorBoundary: typeof all.ErrorBoundary;
+    Icon: default_2.ForwardRefExoticComponent<IconBaseProps & default_2.RefAttributes<unknown>>;
+    Stack: default_2.ForwardRefExoticComponent<{
+        children: default_2.ReactNode;
+        orientation?: string;
+        uid?: string;
+        horizontalAlignment?: string;
+        verticalAlignment?: string;
+        style?: default_2.CSSProperties;
+        reverse?: boolean;
+        hoverContainer?: boolean;
+        visibleOnHover?: boolean;
+        onClick?: any;
+        onMount?: any;
+    } & default_2.RefAttributes<any>>;
+    Button: default_2.ForwardRefExoticComponent<{
+        id?: string;
+        type?: "button" | "reset" | "submit";
+        variant?: "solid" | "outlined" | "ghost";
+        themeColor?: "primary" | "secondary" | "attention";
+        size?: string;
+        disabled?: boolean;
+        children?: default_2.ReactNode | default_2.ReactNode[];
+        icon?: default_2.ReactNode;
+        iconPosition?: "start" | "end";
+        contentPosition?: "center" | "start" | "end";
+        orientation?: "vertical" | "horizontal";
+        formId?: string;
+        style?: default_2.CSSProperties;
+        gap?: string | number;
+        accessibilityProps?: any;
+        autoFocus?: boolean;
+        contextualLabel?: string;
+    } & Pick<default_2.HTMLAttributes<HTMLButtonElement>, "className" | "aria-disabled" | "aria-label" | "aria-controls" | "aria-expanded" | "onClick" | "onFocus" | "onBlur" | "tabIndex" | "onMouseEnter" | "onMouseLeave"> & default_2.RefAttributes<HTMLButtonElement>>;
+    Splitter: ({ initialPrimarySize, minPrimarySize, maxPrimarySize, orientation, children, style, swapped, floating, splitterTemplate, resize, }: {
+        children: default_2.ReactNode | default_2.ReactNode[];
+        style?: default_2.CSSProperties;
+        splitterTemplate?: default_2.ReactNode;
+        orientation?: "vertical" | "horizontal";
+        floating?: boolean;
+        resize?: (sizes: [number, number]) => void;
+        swapped?: boolean;
+        initialPrimarySize?: string;
+        minPrimarySize?: string;
+        maxPrimarySize?: string;
+    }) => default_3.JSX.Element;
+    getColor: typeof all.getColor;
+    TabItem: default_2.ForwardRefExoticComponent<Tab & default_2.RefAttributes<HTMLDivElement>>;
+    Tabs: default_2.ForwardRefExoticComponent<{
+        activeTab?: number;
+        orientation?: "vertical" | "horizontal";
+        tabRenderer?: (item: {
+            label: string;
+            isActive: boolean;
+        }) => default_2.ReactNode;
+        style?: default_2.CSSProperties;
+        children?: default_2.ReactNode;
+        registerComponentApi?: all.RegisterComponentApiFn;
+        className?: string;
+        distributeEvenly?: boolean;
+    } & default_2.RefAttributes<HTMLDivElement>>;
+    useColors: typeof all.useColors;
+    toCssVar: typeof all.toCssVar;
+    useDevTools: typeof all.useDevTools;
+    useLogger: () => {
+        logs: {
+            timestamp: Date;
+            args: any[];
+        }[];
+        addLog: (args: any[]) => void;
+    };
+    errReportComponent: typeof all.errReportComponent;
+    xmlUiMarkupToComponent: typeof all.xmlUiMarkupToComponent;
+    ApiInterceptorProvider: typeof all.ApiInterceptorProvider;
+    Spinner: default_2.ForwardRefExoticComponent<{
+        delay?: number;
+        fullScreen?: boolean;
+        style?: default_2.CSSProperties;
+    } & default_2.RefAttributes<HTMLDivElement>>;
+    builtInThemes: all.ThemeDefinition[];
+    XmlUiHelper: typeof all.XmlUiHelper;
+    Text: default_2.ForwardRefExoticComponent<Omit<{
+        [variantSpecificProps: string]: any;
+        uid?: string;
+        children?: default_2.ReactNode;
+        variant?: "small" | "sub" | "sup" | "abbr" | "caption" | "cite" | "code" | "em" | "strong" | "title" | "var" | "mono" | "secondary" | "codefence" | "deleted" | "inserted" | "keyboard" | "marked" | "sample" | "subtitle" | "placeholder" | "paragraph" | "subheading" | "tableheading";
+        maxLines?: number;
+        preserveLinebreaks?: boolean;
+        ellipses?: boolean;
+        style?: default_2.CSSProperties;
+    }, "ref"> & default_2.RefAttributes<unknown>>;
+    NestedApp: typeof all.NestedApp;
+};
+export default _default;
+
+declare type DefaultThemeVars = Record<string | ThemeTone, string | Record<string, string>>;
+
+declare type DefaultValueDescriptor = (string | ThemeIdDescriptor)[];
+
+declare type DESTRUCTURE = typeof T_DESTRUCTURE;
+
+declare interface Destructure extends DestructureBase {
+    type: DESTRUCTURE;
+    aDestr?: ArrayDestructure[];
+    oDestr?: ObjectDestructure[];
+}
+
+declare interface DestructureBase extends ExpressionBase {
+    id?: string;
+    aDestr?: ArrayDestructure[];
+    oDestr?: ObjectDestructure[];
+}
+
+declare enum DiagnosticCategory {
+    Warning = 0,
+    Error = 1,
+    Suggestion = 2,
+    Message = 3
+}
+
+declare type DO_WHILE_STATEMENT = typeof T_DO_WHILE_STATEMENT;
+
+declare interface DoWhileStatement extends ScripNodeBase {
+    type: DO_WHILE_STATEMENT;
+    cond: Expression;
+    body: Statement;
+}
+
+/**
+ * Some components render their nested child components dynamically using the current context of
+ * their parents. For example, reusable components (`CompoundComponentDef`) have a `Slot`
+ * placeholder that marks the location where the children should be rendered. Other component types
+ * (e.g., `ApiBoundComponent` and `ContainerComponent`) use this dynamic rendering, too.
+ *
+ * This interface represents this functionality.
+ */
+declare interface DynamicChildComponentDef extends ComponentDef {
+    /**
+     * This property holds a function that can render a particular child or children into a specific
+     * layout context.
+     */
+    renderChild: RenderChildFn;
+    /**
+     * This property holds the child component that should be rendered.
+     */
+    childToRender: ComponentDef;
+}
+
+declare type EMPTY_STATEMENT = typeof T_EMPTY_STATEMENT;
+
+declare interface EmptyStatement extends ScripNodeBase {
+    type: EMPTY_STATEMENT;
+}
+
+declare type EntrypointCompilation = CompilationUnit & {
+    /** The compiled markup of the main file */
+    definition: ComponentDef;
+};
+
+declare enum ErrCodes {
+    onlyOneElem = "U002",
+    expTagOpen = "U003",
+    expTagIdent = "U004",
+    expCloseStart = "U005",
+    expEndOrClose = "U006",
+    tagNameMismatch = "U007",
+    expEnd = "U008",
+    expAttrIdent = "U009",
+    expEq = "U010",
+    expAttrValue = "U011",
+    duplAttr = "U012",
+    uppercaseAttr = "U013",
+    invalidChar = "W001",
+    untermStr = "W002",
+    untermComment = "W007",
+    untermCData = "W008",
+    untermScript = "W009"
+}
+
+declare interface Error_2 {
+    readonly category: DiagnosticCategory;
+    readonly code: ErrCodes;
+    readonly message: string;
+    readonly pos: number;
+    readonly end: number;
+}
+
+/**
+ * This React component serves as an error boundary; it catches any errors within
+ * the nested components
+ */
+declare class ErrorBoundary extends default_2.Component<Props, State> {
+    state: State;
+    /**
+     * This method implements the Error Boundaries for the React application.
+     * It is invoked if errors occur during the rendering phase of any lifecycle
+     * methods or children components.
+     *
+     * DO NOT DELETE this method! Though it is not referenced directly from the code,
+     * it is a required part of the React component lifecycle.
+     */
+    static getDerivedStateFromError(error: Error): State;
+    /**
+     * Display any error in the console
+     * @param error Error object
+     * @param errorInfo Extra information about the error
+     */
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    /**
+     * Whenever the `restoreOnChangeOf` property of this component instance
+     * changes, we reset the state to "no error".
+     * @param prevProps Previous property values
+     * @param prevState Previous state
+     * @param snapshot Optional snapshot (not used in this component)
+     */
+    componentDidUpdate(prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any): void;
+    /**
+     * Display an error message if an error occurred during rendering.
+     */
+    render(): string | number | boolean | Iterable<default_2.ReactNode> | JSX_2.Element;
+}
+
+declare interface ErrorWithLineColInfo extends Error_2 {
+    line: number;
+    col: number;
+}
+
+/** returns a component definition containing the errors.
+ * It is a component and a compound component definition at the same time,
+ * so that it can be used to render the errors for a compound component as well*/
+declare function errReportComponent(errors: ErrorWithLineColInfo[], fileName: number | string, compoundCompName: string | undefined): any;
+
+declare type Expression = UnaryExpression | BinaryExpression | SequenceExpression | ConditionalExpression | FunctionInvocationExpression | MemberAccessExpression | CalculatedMemberAccessExpression | Identifier | TemplateLiteralExpression | Literal | ArrayLiteral | ObjectLiteral | SpreadExpression | AssignmentExpression | NoArgExpression | ArrowExpression | PrefixOpExpression | PostfixOpExpression | ReactiveVarDeclaration | VarDeclaration | Destructure | ObjectDestructure | ArrayDestructure | SwitchCase;
+
+declare type EXPRESSION_STATEMENT = typeof T_EXPRESSION_STATEMENT;
+
+declare interface ExpressionBase extends ScripNodeBase {
+    parenthesized?: number;
+}
+
+declare interface ExpressionStatement extends ScripNodeBase {
+    type: EXPRESSION_STATEMENT;
+    expr: Expression;
+}
+
+declare interface Extension {
+    namespace?: string;
+    components?: ComponentExtension[];
+    themes?: ThemeDefinition[];
+}
+
+declare type ExtensionRegisteredCallbackFn = (extension: Extension) => void;
+
+/**
+ * This type describes a font definition resource.
+ */
+declare type FontDef = {
+    /**
+     * Specifies a name that will be used as the font face value for font properties
+     */
+    fontFamily: string;
+    /**
+     * A fontStyle value. Accepts two values to specify a range that is supported by a font-face,
+     * for example `fontStyle: oblique 20deg 50deg`
+     */
+    fontStyle?: string;
+    /**
+     * A font-weight value. Accepts two values to specify a range that is supported by a font-face,
+     * for example `font-weight: 100 900`
+     */
+    fontWeight?: string;
+    /**
+     * This property determines how a font face is displayed based on whether and when it is downloaded
+     * and ready to use.
+     */
+    fontDisplay?: string;
+    /**
+     * The mime type of the font file
+     */
+    format?: string;
+    /**
+     * Specifies references to font resources.
+     */
+    src: string;
+} | string;
+
+declare type FOR_IN_STATEMENT = typeof T_FOR_IN_STATEMENT;
+
+declare type FOR_OF_STATEMENT = typeof T_FOR_OF_STATEMENT;
+
+declare type FOR_STATEMENT = typeof T_FOR_STATEMENT;
+
+declare interface ForInStatement extends ScripNodeBase {
+    type: FOR_IN_STATEMENT;
+    varB: ForVarBinding;
+    id: Identifier;
+    expr: Expression;
+    body: Statement;
+}
+
+declare interface ForOfStatement extends ScripNodeBase {
+    type: FOR_OF_STATEMENT;
+    varB: ForVarBinding;
+    id: Identifier;
+    expr: Expression;
+    body: Statement;
+}
+
+declare interface ForStatement extends ScripNodeBase {
+    type: FOR_STATEMENT;
+    init?: ExpressionStatement | LetStatement;
+    cond?: Expression;
+    upd?: Expression;
+    body: Statement;
+}
+
+declare type ForVarBinding = "let" | "const" | "none";
+
+declare type FUNCTION_DECLARATION = typeof T_FUNCTION_DECLARATION;
+
+declare type FUNCTION_INVOCATION_EXPRESSION = typeof T_FUNCTION_INVOCATION_EXPRESSION;
+
+declare interface FunctionDeclaration extends ScripNodeBase {
+    type: FUNCTION_DECLARATION;
+    id: Identifier;
+    args: Expression[];
+    stmt: BlockStatement;
+}
+
+declare interface FunctionInvocationExpression extends ExpressionBase {
+    type: FUNCTION_INVOCATION_EXPRESSION;
+    obj: Expression;
+    arguments: Expression[];
+}
+
+declare type GenericToken<T> = {
+    text: string;
+    type: T;
+    startPosition: number;
+    endPosition: number;
+    startLine: number;
+    endLine: number;
+    startColumn: number;
+    endColumn: number;
+};
+
+declare function getColor(varName: string, format?: "hex" | "rgb" | "hsl"): string;
+
+declare type GlobalProps = Record<string, any>;
+
+declare interface IApiInterceptorContext {
+    isMocked: (url: string) => boolean;
+}
+
+declare const Icon: default_2.ForwardRefExoticComponent<IconBaseProps & default_2.RefAttributes<unknown>>;
+
+declare interface IconBaseProps extends default_2.SVGAttributes<SVGElement> {
+    children?: default_2.ReactNode;
+    color?: string;
+    title?: string;
+    size?: string;
+    isInline?: boolean;
+    fallback?: string;
+    style?: CSSProperties;
+}
+
+declare type IconPosition = (typeof iconPositionValues)[number];
+
+declare const iconPositionValues: readonly ["start", "end"];
+
+declare type IDENTIFIER = typeof T_IDENTIFIER;
+
+declare interface Identifier extends ExpressionBase {
+    type: IDENTIFIER;
+    name: string;
+    isGlobal?: boolean;
+}
+
+declare type IF_STATEMENT = typeof T_IF_STATEMENT;
+
+declare interface IfStatement extends ScripNodeBase {
+    type: IF_STATEMENT;
+    cond: Expression;
+    thenB: Statement;
+    elseB?: Statement;
+}
+
+declare type InterceptorOperationDef = {
+    method: "get" | "post" | "put" | "delete";
+    url: string | Array<string>;
+    handler: string;
+    requestShape?: any;
+    responseShape?: any;
+    pathParamTypes?: Record<string, string>;
+    queryParamTypes?: Record<string, string>;
+    successStatusCode?: number;
+};
+
+declare type IsValidFunction<T> = (propKey: string, propValue: T) => string | string[] | undefined | null;
+
+/**
+ * Each component is rendered in a particular layout context (for example, within a stack). This
+ * type provides information about that context and the operations that render children in it.
+ */
+declare type LayoutContext<T extends ComponentDef = ComponentDef> = {
+    /**
+     * The type of the layout context
+     */
+    type?: string;
+    /**
+     * This function allows the React representation of a particular child node to be wrapped in
+     * whatever React components to accommodate the current layout context. When the engine is about to
+     * render children in a particular layout context, it checks the existence of this function.
+     * If declared, the engine invokes it.
+     * @param context Rendering context
+     * @param renderedChild The React node representing the rendered child
+     * @param metadata The metadata of the child component
+     * @returns The wrapped React node
+     */
+    wrapChild?: (context: RendererContext<T>, renderedChild: ReactNode, metadata?: ComponentMetadata) => ReactNode;
+    /**
+     * Arbitrary props extending the layout context
+     */
+    [key: string]: any;
+};
+
+declare type LET_STATEMENT = typeof T_LET_STATEMENT;
+
+declare interface LetStatement extends ScripNodeBase {
+    type: LET_STATEMENT;
+    decls: VarDeclaration[];
+}
+
+declare type LITERAL = typeof T_LITERAL;
+
+declare interface Literal extends ExpressionBase {
+    type: LITERAL;
+    value: any;
+}
+
+declare type LogContextType = {
+    logs: LogEntry[];
+    addLog: (args: any[]) => void;
+};
+
+declare type LogEntry = {
+    timestamp: Date;
+    args: any[];
+};
+
+declare type LoggedInUserDto = {
+    id: number;
+    email: string;
+    name: string;
+    imageRelativeUrl: string;
+    permissions: Record<string, string>;
+};
+
+/**
+ * This type represents the options to use for looking up actions.
+ */
+declare type LookupActionOptions = {
+    /**
+     * This property (by default, true) indicates that any error should be signed while
+     * executing an event handler. Set it to `false` to suppress error indication.
+     */
+    signError?: boolean;
+    /**
+     * We can use the event's name to get info about a particular event's progress. Note: Multiple
+     * events can run simultaneously.
+     */
+    eventName?: string;
+    /**
+     * By default, we cache resolved action functions. This property signs that we don't want to cache
+     * this function. Use true on one-off handlers, like the ones in Actions (e.g., `MutateAction`).
+     */
+    ephemeral?: boolean;
+    /**
+     * This property declares the script code to use as a default for a particular event handler.
+     */
+    defaultHandler?: string;
+    context?: any;
+};
+
+/**
+ * This function resolves an action by its name with the specified options and returns the action
+ * function if found. Otherwise, return undefined.
+ */
+declare type LookupAsyncFn = (action: string | undefined, actionOptions?: LookupActionOptions) => AsyncFunction | undefined;
+
+/**
+ * This function resolves an action by its name (within the component node that runs the action)
+ * with the specified options and returns the action function if found. Otherwise, return undefined.
+ */
+declare type LookupAsyncFnInner = (action: string | undefined, 
+/**
+ * The unique identifier of the container that the action is executed in.
+ */
+uid: symbol, actionOptions?: LookupActionOptions) => AsyncFunction | undefined;
+
+/**
+ * This function retrieves an async function for a particular component's specified event to be
+ * invoked as an event handler (`undefined` if the particular event handler is not defined).
+ */
+declare type LookupEventHandlerFn<TMd extends ComponentMetadata = ComponentMetadata> = (eventName: keyof NonNullable<TMd["events"]>, actionOptions?: LookupActionOptions) => AsyncFunction | undefined;
+
+/**
+ * This function resolves a sync action by its name and returns the action function if it is found.
+ * Otherwise, it returns undefined.
+ */
+declare type LookupSyncFn = (action: string | undefined) => SyncFunction | undefined;
+
+declare type MediaBreakpointType = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+
+declare type MediaSize = {
+    phone: boolean;
+    landscapePhone: boolean;
+    tablet: boolean;
+    desktop: boolean;
+    largeDesktop: boolean;
+    xlDesktop: boolean;
+    smallScreen: boolean;
+    largeScreen: boolean;
+    size: MediaBreakpointType;
+    sizeIndex: number;
+};
+
+declare type MEMBER_ACCESS_EXPRESSION = typeof T_MEMBER_ACCESS_EXPRESSION;
+
+declare interface MemberAccessExpression extends ExpressionBase {
+    type: MEMBER_ACCESS_EXPRESSION;
+    obj: Expression;
+    member: string;
+    opt?: boolean;
+}
+
+declare type Message = ValueOrFunction<Renderable, Toast>;
+
+/**
+ * Represents a module error
+ */
+declare type ModuleErrors = Record<string, ScriptParserErrorMessage[]>;
+
+declare function NestedApp({ api, app, components, config, activeTheme, activeTone, title, height, allowPlaygroundPopup, withFrame }: NestedAppProps): JSX_2.Element;
+
+declare type NestedAppProps = {
+    api?: any;
+    app: string;
+    components?: any[];
+    config?: any;
+    activeTone?: ThemeTone;
+    activeTheme?: string;
+    title?: string;
+    height?: string | number;
+    allowPlaygroundPopup?: boolean;
+    withFrame?: boolean;
+};
+
+declare type NO_ARG_EXPRESSION = typeof T_NO_ARG_EXPRESSION;
+
+declare interface NoArgExpression extends ExpressionBase {
+    type: NO_ARG_EXPRESSION;
+}
+
+declare type OBJECT_DESTRUCTURE = typeof T_OBJECT_DESTRUCTURE;
+
+declare type OBJECT_LITERAL = typeof T_OBJECT_LITERAL;
+
+declare interface ObjectDestructure extends DestructureBase {
+    type: OBJECT_DESTRUCTURE;
+    id: string;
+    alias?: string;
+}
+
+declare interface ObjectLiteral extends ExpressionBase {
+    type: OBJECT_LITERAL;
+    props: (SpreadExpression | [Expression, Expression])[];
+}
+
+declare type OrientationOptions = (typeof orientationOptionValues)[number];
+
+declare const orientationOptionValues: readonly ["horizontal", "vertical"];
+
+declare interface ParentRenderContext {
+    renderChild: RenderChildFn;
+    children?: ComponentDef[];
+    props?: Record<string, any>;
+}
+
+/**
+ * This function extracts CSS variables from the specified SCSS input. It uses a hack to convert the CSS input to JSON
+ * and then calls a JSON parser to create the desired object.
+ * @param scssStr The scss input
+ */
+declare function parseScssVar(scssStr: any): any;
+
+declare type POSTFIX_OP_EXPRESSION = typeof T_POSTFIX_OP_EXPRESSION;
+
+declare interface PostfixOpExpression extends ExpressionBase {
+    type: POSTFIX_OP_EXPRESSION;
+    op: PrefixOpSymbol;
+    expr: Expression;
+}
+
+declare type PREFIX_OP_EXPRESSION = typeof T_PREFIX_OP_EXPRESSION;
+
+declare interface PrefixOpExpression extends ExpressionBase {
+    type: PREFIX_OP_EXPRESSION;
+    op: PrefixOpSymbol;
+    expr: Expression;
+}
+
+declare type PrefixOpSymbol = "++" | "--";
+
+/** Contains the compilation result of a project */
+declare type ProjectCompilation = {
+    /** The compiled Main.xmlui file (with its optional code behind) */
+    entrypoint: EntrypointCompilation;
+    /** The compiled component files (with their optional code behind) */
+    components: ComponentCompilation[];
+    /** The compiled theme files */
+    themes: Record<string, ThemeDefinition>;
+};
+
+/**
+ * This type represents the description of a property value, which can be a string, a number,
+ * or an object with a value and a description. This type is used in the metadata of a component.
+ */
+declare type PropertyValueDescription = string | number | {
+    value: string | number;
+    description: string;
+};
+
+declare type PropertyValueType = "boolean" | "string" | "number" | "any" | "ComponentDef";
+
+declare interface Props {
+    children: ReactNode;
+    node?: ComponentLike;
+    location?: string;
+}
+
+declare type Props_2 = {
+    children: ReactNode;
+    orientation?: string;
+    uid?: string;
+    horizontalAlignment?: string;
+    verticalAlignment?: string;
+    style?: CSSProperties;
+    reverse?: boolean;
+    hoverContainer?: boolean;
+    visibleOnHover?: boolean;
+    onClick?: any;
+    onMount?: any;
+};
+
+declare type Props_3 = {
+    activeTab?: number;
+    orientation?: "horizontal" | "vertical";
+    tabRenderer?: (item: {
+        label: string;
+        isActive: boolean;
+    }) => ReactNode;
+    style?: CSSProperties;
+    children?: ReactNode;
+    registerComponentApi?: RegisterComponentApiFn;
+    className?: string;
+    distributeEvenly?: boolean;
+};
+
+declare type REACTIVE_VAR_DECLARATION = typeof T_REACTIVE_VAR_DECLARATION;
+
+declare interface ReactiveVarDeclaration extends ExpressionBase {
+    type: REACTIVE_VAR_DECLARATION;
+    id: Identifier;
+    expr: Expression;
+}
+
+/**
+ * This type represents a function that registers all API endpoints of a particular component.
+ */
+declare type RegisterComponentApiFn = (componentApi: ComponentApi) => void;
+
+declare type RenderChildFn<L extends ComponentDef = ComponentDef> = (children?: ComponentDef | ComponentDef[] | DynamicChildComponentDef | DynamicChildComponentDef[] | string, layoutContext?: LayoutContext<L>, parentRenderContext?: ParentRenderContext, uidInfoRef?: RefObject<Record<string, any>>, ref?: ForwardedRef<any>) => ReactNode | ReactNode[];
+
+/**
+ * This interface defines the renderer context for the exposed components of the XMLUI framework.
+ */
+declare interface RendererContext<TMd extends ComponentMetadata = ComponentMetadata> extends ComponentRendererContextBase<TMd> {
+    /**
+     * The unique identifier of the component instance
+     */
+    uid: symbol;
+    /**
+     * A component invokes this function to change its internal state
+     */
+    updateState: UpdateStateFn;
+    /**
+     * When a component wants to access a property value (which may contain a binding expression to
+     * evaluate), it must use this property to get the current value.
+     */
+    extractValue: ValueExtractor;
+    /**
+     * This function gets a physical resource URL according to the provided logical URL.
+     */
+    extractResourceUrl: (url?: string) => string | undefined;
+    /**
+     * This function gets an async executable function that handles an event.
+     */
+    lookupEventHandler: LookupEventHandlerFn<TMd>;
+    /**
+     * A component can register its APIs with this function
+     */
+    registerComponentApi: RegisterComponentApiFn;
+    /**
+     * This function obtains an action by its name with the specified options
+     */
+    lookupAction: LookupAsyncFn;
+    /**
+     * This function retrieves a sync function the component can use as a callback
+     */
+    lookupSyncCallback: LookupSyncFn;
+    layoutCss: CSSProperties;
+}
+
+declare type RETURN_STATEMENT = typeof T_RETURN_STATEMENT;
+
+declare interface ReturnStatement extends ScripNodeBase {
+    type: RETURN_STATEMENT;
+    expr?: Expression;
+}
+
+declare type SchemaDescriptor = {
+    tables: Array<TableDescriptor>;
+    relationships?: any;
+    dtos?: any;
+};
+
+declare interface ScripNodeBase {
+    type: ScriptNode["type"];
+    nodeId: number;
+    startToken?: ScriptingToken;
+    endToken?: ScriptingToken;
+}
+
+/**
+ * This interface holds the properties representing a scriptable component definition.
+ */
+declare interface Scriptable {
+    /**
+     * This property holds the text defined in all <script> sections attached to a component.
+     */
+    script?: string;
+    /**
+     * This property holds the parsed form of scripts stored in code-behind files.
+     */
+    scriptCollected?: CollectedDeclarations;
+    /**
+     * This property holds errors coming from parsing the code-behind scripts.
+     */
+    scriptError?: any;
+}
+
+declare type ScriptingToken = GenericToken<TokenType>;
+
+declare type ScriptNode = Statement | Expression;
+
+declare interface ScriptParserErrorMessage {
+    code: ScriptParsingErrorCodes;
+    text: string;
+    position?: number;
+    line?: number;
+    column?: number;
+}
+
+declare type ScriptParsingErrorCodes = "W001" | "W002" | "W003" | "W004" | "W005" | "W006" | "W007" | "W008" | "W009" | "W010" | "W011" | "W012" | "W013" | "W014" | "W015" | "W016" | "W017" | "W018" | "W019" | "W020" | "W021" | "W022" | "W023" | "W024" | "W025" | "W026" | "W027" | "W028" | "W029" | "W030" | "W031";
+
+declare type SEQUENCE_EXPRESSION = typeof T_SEQUENCE_EXPRESSION;
+
+declare interface SequenceExpression extends ExpressionBase {
+    type: SEQUENCE_EXPRESSION;
+    exprs: Expression[];
+    loose?: boolean;
+}
+
+declare const sizeValues: string[];
+
+declare const Spinner: ForwardRefExoticComponent<SpinnerProps & RefAttributes<HTMLDivElement>>;
+
+declare type SpinnerProps = {
+    delay?: number;
+    fullScreen?: boolean;
+    style?: CSSProperties;
+};
+
+declare const Splitter: ({ initialPrimarySize, minPrimarySize, maxPrimarySize, orientation, children, style, swapped, floating, splitterTemplate, resize, }: SplitterProps) => JSX_2.Element;
+
+declare type SplitterProps = {
+    children: default_2.ReactNode[] | default_2.ReactNode;
+    style?: default_2.CSSProperties;
+    splitterTemplate?: default_2.ReactNode;
+    orientation?: OrientationOptions;
+    floating?: boolean;
+    resize?: (sizes: [number, number]) => void;
+    swapped?: boolean;
+    initialPrimarySize?: string;
+    minPrimarySize?: string;
+    maxPrimarySize?: string;
+};
+
+declare type SPREAD_EXPRESSION = typeof T_SPREAD_EXPRESSION;
+
+declare interface SpreadExpression extends ExpressionBase {
+    type: SPREAD_EXPRESSION;
+    expr: Expression;
+}
+
+declare const Stack: ForwardRefExoticComponent<Props_2 & RefAttributes<any>>;
+
+/**
+ * This React component represents a standalone app that implements a web
+ * application with xmlui components. A StandaloneApp instance uses a
+ * AppRoot wrapped into an ApiInterceptor.
+ *
+ * AppRoot is responsible for rendering the app (using an internal
+ * representation); ApiInterceptor can emulate some backend functionality
+ * running in the browser.
+ */
+declare function StandaloneApp({ appDef, decorateComponentsWithTestId, debugEnabled, runtime, extensionManager, }: StandaloneAppProps): JSX_2.Element;
+
+declare type StandaloneAppDescription = {
+    name?: string;
+    version?: string;
+    entryPoint?: ComponentLike;
+    components?: CompoundComponentDef[];
+    themes?: ThemeDefinition[];
+    defaultTheme?: string;
+    defaultTone?: string;
+    resources?: Record<string, string>;
+    resourceMap?: Record<string, string>;
+    appGlobals?: Record<string, any>;
+    apiInterceptor?: ApiInterceptorDefinition;
+    sources?: Record<string, string>;
+};
+
+declare type StandaloneAppProps = {
+    appDef?: StandaloneAppDescription;
+    decorateComponentsWithTestId?: boolean;
+    debugEnabled?: boolean;
+    runtime?: any;
+    extensionManager?: StandaloneExtensionManager;
+};
+
+/**
+ * This class allows external component libraries to add their components to
+ * the xmlui component registry. The framework resolves the components used
+ * in an application markup with this registry.
+ */
+declare class StandaloneExtensionManager {
+    subscriptions: Set<ExtensionRegisteredCallbackFn>;
+    registeredExtensions: Array<Extension>;
+    constructor();
+    /**
+     * You can add a callback function invoked whenever a new component is added
+     * to the registry. When you register a new callback function, the component
+     * manager automatically invokes it for all components already in the
+     * registry.
+     * @param cb Function to call when a new component is registered
+     */
+    subscribeToRegistrations(cb: ExtensionRegisteredCallbackFn): void;
+    /**
+     * You can remove a function added by `subscribeToRegistrations`. After
+     * calling this method, the particular callback function won't be invoked
+     * for a new component registration.
+     * @param cb Function to call when a new component is registered
+     */
+    unSubscribeFromRegistrations(cb: ExtensionRegisteredCallbackFn): void;
+    registerExtension(component: Extension | Extension[]): void;
+}
+
+declare type StandaloneJsonConfig = {
+    name?: string;
+    appGlobals?: Record<string, any>;
+    entryPoint?: string;
+    components?: string[];
+    themes?: string[];
+    defaultTheme?: string;
+    resources?: Record<string, string>;
+    resourceMap?: Record<string, string>;
+    apiInterceptor?: ApiInterceptorDefinition;
+};
+
+/**
+ * This function injects the StandaloneApp component into a React app. It looks
+ * up a component with the "root" id as the host of the standalone app. If such
+ * an element does not exist, it creates a `<div id="root">` element.
+ * @param runtime The app's runtime representation
+ * @param components The related component's runtime representation
+ * @returns The content's root element
+ */
+declare function startApp(runtime: any, extensions?: Extension[] | Extension, extensionManager?: StandaloneExtensionManager): Root;
+
+declare type State = {
+    hasError: boolean;
+    error: Error | null;
+};
+
+declare type Statement = BlockStatement | EmptyStatement | ExpressionStatement | ArrowExpressionStatement | LetStatement | ConstStatement | VarStatement | IfStatement | ReturnStatement | BreakStatement | ContinueStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | ThrowStatement | TryStatement | SwitchStatement | FunctionDeclaration;
+
+declare type SWITCH_CASE = typeof T_SWITCH_CASE;
+
+declare type SWITCH_STATEMENT = typeof T_SWITCH_STATEMENT;
+
+declare interface SwitchCase extends ExpressionBase {
+    type: SWITCH_CASE;
+    caseE?: Expression;
+    stmts?: Statement[];
+}
+
+declare interface SwitchStatement extends ScripNodeBase {
+    type: SWITCH_STATEMENT;
+    expr: Expression;
+    cases: SwitchCase[];
+}
+
+/**
+ * XMLUI executes some code synchronously. This type defines those functions' signature
+ */
+declare type SyncFunction = (...args: any) => any;
+
+declare const T_ARRAY_DESTRUCTURE = 202;
+
+declare const T_ARRAY_LITERAL = 110;
+
+declare const T_ARROW_EXPRESSION = 115;
+
+declare const T_ARROW_EXPRESSION_STATEMENT = 4;
+
+declare const T_ASSIGNMENT_EXPRESSION = 113;
+
+declare const T_BINARY_EXPRESSION = 101;
+
+declare const T_BLOCK_STATEMENT = 1;
+
+declare const T_BREAK_STATEMENT = 10;
+
+declare const T_CALCULATED_MEMBER_ACCESS_EXPRESSION = 106;
+
+declare const T_CONDITIONAL_EXPRESSION = 103;
+
+declare const T_CONST_STATEMENT = 6;
+
+declare const T_CONTINUE_STATEMENT = 11;
+
+declare const T_DESTRUCTURE = 201;
+
+declare const T_DO_WHILE_STATEMENT = 13;
+
+declare const T_EMPTY_STATEMENT = 2;
+
+declare const T_EXPRESSION_STATEMENT = 3;
+
+declare const T_FOR_IN_STATEMENT = 15;
+
+declare const T_FOR_OF_STATEMENT = 16;
+
+declare const T_FOR_STATEMENT = 14;
+
+declare const T_FUNCTION_DECLARATION = 20;
+
+declare const T_FUNCTION_INVOCATION_EXPRESSION = 104;
+
+declare const T_IDENTIFIER = 107;
+
+declare const T_IF_STATEMENT = 8;
+
+declare const T_LET_STATEMENT = 5;
+
+declare const T_LITERAL = 109;
+
+declare const T_MEMBER_ACCESS_EXPRESSION = 105;
+
+declare const T_NO_ARG_EXPRESSION = 114;
+
+declare const T_OBJECT_DESTRUCTURE = 203;
+
+declare const T_OBJECT_LITERAL = 111;
+
+declare const T_POSTFIX_OP_EXPRESSION = 117;
+
+declare const T_PREFIX_OP_EXPRESSION = 116;
+
+declare const T_REACTIVE_VAR_DECLARATION = 118;
+
+declare const T_RETURN_STATEMENT = 9;
+
+declare const T_SEQUENCE_EXPRESSION = 102;
+
+declare const T_SPREAD_EXPRESSION = 112;
+
+declare const T_SWITCH_CASE = 204;
+
+declare const T_SWITCH_STATEMENT = 19;
+
+declare const T_TEMPLATE_LITERAL_EXPRESSION = 108;
+
+declare const T_THROW_STATEMENT = 17;
+
+declare const T_TRY_STATEMENT = 18;
+
+declare const T_UNARY_EXPRESSION = 100;
+
+declare const T_VAR_DECLARATION = 200;
+
+declare const T_VAR_STATEMENT = 7;
+
+declare const T_WHILE_STATEMENT = 12;
+
+declare type Tab = {
+    label: string;
+    children?: ReactNode;
+    style?: CSSProperties;
+};
+
+declare const TabItemComponent: ForwardRefExoticComponent<Tab & RefAttributes<HTMLDivElement>>;
+
+declare type TableDescriptor = {
+    name: string;
+    fields?: Record<string, any>;
+    pk: Array<string>;
+    indexes?: Array<string>;
+};
+
+declare const Tabs: ForwardRefExoticComponent<Props_3 & RefAttributes<HTMLDivElement>>;
+
+declare type TEMPLATE_LITERAL_EXPRESSION = typeof T_TEMPLATE_LITERAL_EXPRESSION;
+
+declare interface TemplateLiteralExpression extends ExpressionBase {
+    type: TEMPLATE_LITERAL_EXPRESSION;
+    segments: (Literal | Expression)[];
+}
+
+declare const Text_2: default_2.ForwardRefExoticComponent<Omit<TextProps, "ref"> & default_2.RefAttributes<unknown>>;
+
+declare type TextProps = {
+    uid?: string;
+    children?: default_2.ReactNode;
+    variant?: TextVariant;
+    maxLines?: number;
+    preserveLinebreaks?: boolean;
+    ellipses?: boolean;
+    style?: CSSProperties;
+    [variantSpecificProps: string]: any;
+};
+
+declare type TextVariant = (typeof TextVariantKeys)[number];
+
+declare const TextVariantKeys: readonly ["abbr", "cite", "code", "codefence", "deleted", "inserted", "keyboard", "marked", "sample", "sub", "sup", "var", "strong", "em", "mono", "title", "subtitle", "small", "caption", "placeholder", "paragraph", "subheading", "tableheading", "secondary"];
+
+/**
+ * This type represents a theme definition object. Theme files can use this object's JSON-serialized
+ * format to define an app theme; an app can have multiple theme files.
+ */
+declare interface ThemeDefinition extends ThemeDefinitionDetails {
+    /**
+     * Theme id
+     */
+    id: string;
+    /**
+     * Optional theme name
+     */
+    name?: string;
+    /**
+     * A theme can extend existing themes. The extension means that the theme variable values defined
+     * in the new theme override the base theme's variable values.
+     */
+    extends?: string | Array<string>;
+    /**
+     * This property defines the tone-dependent theme variable values. When a theme variable value is
+     * resolved, the common theme variable values are overridden with their theme-specific values.
+     */
+    tones?: Record<string | ThemeTone, ThemeDefinitionDetails>;
+}
+
+declare interface ThemeDefinitionDetails {
+    themeVars?: Record<string, string>;
+    resources?: Record<string, string | FontDef>;
+}
+
+declare type ThemeIdDescriptor = {
+    id: string;
+    defaultValue?: DefaultValueDescriptor;
+};
+
+/**
+ * When rendering any part of an XMLUI app, the styles to apply are enclosed in a theme scope.
+ * Most apps use a single theme scope that includes all nodes within the root app node. However,
+ * any app can use multiple theme scopes.
+ *
+ * The scope determines how the app applies styles to the particular section. This type defines
+ * the properties of such a theme scope.
+ */
+declare type ThemeScope = {
+    /**
+     * Gets the id of the scope's theme
+     */
+    activeThemeId: string;
+    /**
+     * Gets the current tone of the scope's theme
+     */
+    activeThemeTone: ThemeTone;
+    /**
+     * The HTML element that works as the root of the theme's scope.
+     */
+    root: HTMLElement | undefined;
+    /**
+     * The active theme in the current scope
+     */
+    activeTheme: ThemeDefinition;
+    /**
+     * This hash object stores the CSS theme variable names with their CSS values definition,
+     * like "--xmlui-verticalAlign-Text-sub": "sub";
+     * "--xmlui-backgroundColor": "var(--xmlui-color-surface-50)"
+     */
+    themeStyles: Record<string, string>;
+    /**
+     * This hash object stores the theme variable names with their CSS values definition, like
+     * "verticalAlign-Text-sub": "sub"; "backgroundColor": "var(--xmlui-color-surface-50)".
+     */
+    themeVars: Record<string, string>;
+    /**
+     * This function retrieves the physical path of the provided resource. The path can be used
+     * as a URL in HTML tags, like in the `src` attribute of `<img>`.
+     * @param resourceString The recource name to resolve to an URL
+     */
+    getResourceUrl: (resourceString?: string) => string | undefined;
+    /**
+     * This function gets the value of the specified theme variable.
+     * @param themeVar Theme variable name to resolve
+     */
+    getThemeVar: (themeVar: string) => string | undefined;
+};
+
+/**
+ * This type describes one the available theme tones.
+ */
+declare type ThemeTone = (typeof ThemeToneKeys)[number];
+
+/**
+ * Each theme can have a light or a dark tone.
+ */
+declare const ThemeToneKeys: readonly ["light", "dark"];
+
+declare type THROW_STATEMENT = typeof T_THROW_STATEMENT;
+
+declare interface ThrowStatement extends ScripNodeBase {
+    type: THROW_STATEMENT;
+    expr: Expression;
+}
+
+declare type ToastHandler = (message: Message, options?: ToastOptions) => string;
+
+/**
+ * Converts the specified themeID to a CSS var string
+ * @param c segment to convert
+ */
+declare function toCssVar(c: string | ThemeIdDescriptor): string;
+
+declare enum TokenType {
+    Eof = -1,
+    Ws = -2,
+    BlockComment = -3,
+    EolComment = -4,
+    Unknown = 0,
+    LParent = 1,
+    RParent = 2,
+    Identifier = 3,
+    Exponent = 4,
+    Divide = 5,
+    Multiply = 6,
+    Remainder = 7,
+    Plus = 8,
+    Minus = 9,
+    BitwiseXor = 10,
+    BitwiseOr = 11,
+    LogicalOr = 12,
+    BitwiseAnd = 13,
+    LogicalAnd = 14,
+    IncOp = 15,
+    DecOp = 16,
+    Assignment = 17,
+    AddAssignment = 18,
+    SubtractAssignment = 19,
+    ExponentAssignment = 20,
+    MultiplyAssignment = 21,
+    DivideAssignment = 22,
+    RemainderAssignment = 23,
+    ShiftLeftAssignment = 24,
+    ShiftRightAssignment = 25,
+    SignedShiftRightAssignment = 26,
+    BitwiseAndAssignment = 27,
+    BitwiseXorAssignment = 28,
+    BitwiseOrAssignment = 29,
+    LogicalAndAssignment = 30,
+    LogicalOrAssignment = 31,
+    NullCoalesceAssignment = 32,
+    Semicolon = 33,
+    Comma = 34,
+    Colon = 35,
+    LSquare = 36,
+    RSquare = 37,
+    QuestionMark = 38,
+    NullCoalesce = 39,
+    OptionalChaining = 40,
+    BinaryNot = 41,
+    LBrace = 42,
+    RBrace = 43,
+    Equal = 44,
+    StrictEqual = 45,
+    LogicalNot = 46,
+    NotEqual = 47,
+    StrictNotEqual = 48,
+    LessThan = 49,
+    LessThanOrEqual = 50,
+    ShiftLeft = 51,
+    GreaterThan = 52,
+    GreaterThanOrEqual = 53,
+    ShiftRight = 54,
+    SignedShiftRight = 55,
+    Dot = 56,
+    Spread = 57,
+    Global = 58,
+    Backtick = 59,
+    DollarLBrace = 60,
+    Arrow = 61,
+    DecimalLiteral = 62,
+    HexadecimalLiteral = 63,
+    BinaryLiteral = 64,
+    RealLiteral = 65,
+    StringLiteral = 66,
+    Infinity = 67,
+    NaN = 68,
+    True = 69,
+    False = 70,
+    Typeof = 71,
+    Null = 72,
+    Undefined = 73,
+    In = 74,
+    Let = 75,
+    Const = 76,
+    Var = 77,
+    If = 78,
+    Else = 79,
+    Return = 80,
+    Break = 81,
+    Continue = 82,
+    Do = 83,
+    While = 84,
+    For = 85,
+    Of = 86,
+    Try = 87,
+    Catch = 88,
+    Finally = 89,
+    Throw = 90,
+    Switch = 91,
+    Case = 92,
+    Default = 93,
+    Delete = 94,
+    Function = 95,
+    As = 96,
+    From = 97
+}
+
+declare type TrackContainerHeight = "auto" | "fixed";
+
+declare interface TreeNode {
+    uid: string;
+    key: string;
+    path: any[];
+    subPath?: string;
+    displayName?: string;
+    children?: TreeNode[];
+    parentIds: string[];
+    selectable: boolean;
+    groupKey?: string;
+    [x: string]: any;
+}
+
+declare type TRY_STATEMENT = typeof T_TRY_STATEMENT;
+
+declare interface TryStatement extends ScripNodeBase {
+    type: TRY_STATEMENT;
+    tryB: BlockStatement;
+    catchB?: BlockStatement;
+    catchV?: Identifier;
+    finallyB?: BlockStatement;
+}
+
+declare type UNARY_EXPRESSION = typeof T_UNARY_EXPRESSION;
+
+declare interface UnaryExpression extends ExpressionBase {
+    type: UNARY_EXPRESSION;
+    op: UnaryOpSymbols;
+    expr: Expression;
+}
+
+declare type UnaryOpSymbols = "+" | "-" | "~" | "!" | "typeof" | "delete";
+
+/**
+ * This function updates the state of a component.
+ * @param componentState The new state of the component
+ */
+declare type UpdateStateFn = (componentState: any, options?: any) => void;
+
+declare function useColors(...colorNames: (string | ColorDef)[]): Record<string, string>;
+
+declare function useDevTools(): {
+    projectCompilation: ProjectCompilation;
+    inspectedNode: any;
+    sources: Record<string, string>;
+    setIsOpen: (isOpen: boolean) => void;
+    devToolsSize: number;
+    setDevToolsSize: (size: number) => void;
+    devToolsSide: "left" | "right" | "bottom";
+    setDevToolsSide: (side: "left" | "right" | "bottom") => void;
+    devToolsEnabled: boolean;
+    mockApi: any;
+};
+
+declare const useLogger: () => LogContextType;
+
+declare function useTheme(): ThemeScope;
+
+/**
+ * This type represent the function that extracts the value from a component property
+ */
+declare type ValueExtractor = {
+    /**
+     * Get a value (any) from a component property
+     * @param expression Value expression
+     * @param strict Strict matching?
+     */
+    (expression?: any, strict?: boolean): any;
+    /**
+     * Get a string value from an expression
+     * @param expression Value expression
+     */
+    asString(expression?: any): string;
+    /**
+     * Get an optional string value from an expression
+     * @param expression Value expression
+     * @param defValue Default value, if the parameter value is undefined
+     */
+    asOptionalString<T extends string>(expression?: any, defValue?: string): T | undefined;
+    /**
+     * Get an optional string value from an expression
+     * @param expression Value expression
+     */
+    asOptionalStringArray(expression?: any): (string | undefined)[];
+    /**
+     * Get a display string value from an expression
+     * @param expression Value expression
+     */
+    asDisplayText(expression?: any): string;
+    /**
+     * Get a number value from an expression
+     * @param expression Value expression
+     */
+    asNumber(expression?: any): number;
+    /**
+     * Get an optional number value from an expression
+     * @param expression Value expression
+     * @param defValue Default value, if the parameter value is undefined
+     */
+    asOptionalNumber(expression?: any, defValue?: number): number | undefined;
+    /**
+     * Get a boolean value (JavaScript semantics) from an expression
+     * @param expression Value expression
+     */
+    asBoolean(expression?: any): boolean;
+    /**
+     * Get an optional Boolean value from an expression
+     * @param expression Value expression
+     * @param defValue Default value, if the parameter value is undefined
+     */
+    asOptionalBoolean(expression?: any, defValue?: boolean): boolean | undefined;
+    /**
+     * Get a CSS size value from an expression
+     * @param expression Value expression
+     */
+    asSize(expression?: any): string;
+};
+
+declare type VAR_DECLARATION = typeof T_VAR_DECLARATION;
+
+declare type VAR_STATEMENT = typeof T_VAR_STATEMENT;
+
+declare interface VarDeclaration extends ExpressionBase {
+    type: VAR_DECLARATION;
+    id?: string;
+    aDestr?: ArrayDestructure[];
+    oDestr?: ObjectDestructure[];
+    expr?: Expression;
+}
+
+declare interface VarStatement extends ScripNodeBase {
+    type: VAR_STATEMENT;
+    decls: ReactiveVarDeclaration[];
+}
+
+declare type WHILE_STATEMENT = typeof T_WHILE_STATEMENT;
+
+declare interface WhileStatement extends ScripNodeBase {
+    type: WHILE_STATEMENT;
+    cond: Expression;
+    body: Statement;
+}
+
+declare interface XmlUiAttribute extends XmlUiNodeBase {
+    type: "XmlUiAttribute";
+    name: string;
+    namespace?: string;
+    value?: string;
+    preserveQuotes?: boolean;
+    preserveSpaces?: boolean;
+}
+
+declare interface XmlUiComment extends XmlUiNodeBase {
+    type: "XmlUiComment";
+    text?: string;
+}
+
+declare interface XmlUiElement extends XmlUiNodeBase {
+    type: "XmlUiElement";
+    name: string;
+    namespace?: string;
+    attributes?: XmlUiAttribute[];
+    text?: string;
+    preserveSpaces?: boolean;
+    childNodes?: XmlUiNode[];
+}
+
+declare type XmlUiFragment = XmlUiNode | XmlUiNode[];
+
+/**
+ * Helper class for XMLUI serialization and parsing
+ */
+declare class XmlUiHelper {
+    /**
+     * Serialize the specified XML fragment into a string
+     * @param xml XML fragment to serialize
+     * @param options Formatting options to use
+     */
+    serialize(xml: XmlUiFragment, options?: XmluiSerializationOptions): string;
+    /**
+     * Transform the specified component definition into an XMLUI node
+     * @param def Component definitions
+     * @param options Transformation options
+     */
+    transformComponentDefinition(def: ComponentDef | CompoundComponentDef, options?: XmlUiTransformOptions): XmlUiFragment;
+    /**
+     * Transform the specified object into an XMLUI nodes
+     * @param def Object definition
+     * @param options Transformation options
+     */
+    transformObject(def: Record<string, any>, options?: XmlUiTransformOptions): XmlUiNode[] | null;
+    /**
+     * Transforms the specified simple component definition into an XMLUI node
+     * @param def Component definition
+     * @param options Transformation options
+     */
+    private transformSimpleComponentDefinition;
+    /**
+     * Transforms the specified simple component definition into an Xml node
+     * @param def Compound component definition
+     * @param options Transformation options
+     */
+    private transformCompoundComponentDefinition;
+    /**
+     * Transforms a value into an XMLUI element
+     * @param nodeName Name of the value node
+     * @param name Optional (property) name
+     * @param value Value to transform
+     * @param options Transformation options
+     */
+    private transformValue;
+    /**
+     * Transforms the specified simple component definition into an Xml node
+     * @param name Element name
+     * @param value Value to transform
+     * @param options Transformation options
+     */
+    private transformObjectValue;
+    /**
+     * Add a property to the specified XMLUI element
+     * @param element XML element
+     * @param name Element name
+     * @param value Element value
+     * @param options Transformation options
+     */
+    private addProperty;
+    private addComponentElement;
+    /**
+     * Adds a list to the specified XML element
+     * @param element XML element
+     * @param name Name of the list (child in `element`)
+     * @param prefix Prefix to use for the list
+     * @param list List with items
+     * @param options Transformation options
+     */
+    private addList;
+    /**
+     * Adds a component list to the specified element
+     * @param element XML element
+     * @param name Name to use for the wrapper element
+     * @param list List with component items
+     * @private
+     */
+    private addComponentList;
+}
+
+declare function xmlUiMarkupToComponent(source: string, fileId?: string | number): {
+    component: null | ComponentDef | CompoundComponentDef;
+    errors: ErrorWithLineColInfo[];
+    erroneousCompoundComponentName?: string;
+};
+
+declare type XmlUiNode = XmlUiComment | XmlUiAttribute | XmlUiElement;
+
+declare interface XmlUiNodeBase {
+    type: XmlUiNode["type"];
+}
+
+declare type XmluiSerializationOptions = {
+    prettify?: boolean;
+    indents?: number;
+    lineLength?: number;
+    useQuotes?: boolean;
+    useSpaceBeforeClose?: boolean;
+    breakClosingTag?: boolean;
+};
+
+/**
+ * Options to use with markup transformation from memory format to XMLUI structure
+ */
+declare type XmlUiTransformOptions = {
+    preserveLineBreaks?: boolean;
+    preserveSpecialChars?: boolean;
+    removeQuotes?: boolean;
+    extractProps?: boolean;
+    preferTextToValue?: boolean;
+};
+
 export { }