xmlui 0.7.14 → 0.7.16

package/dist/xmlui.d.ts

@@ -1,4 +1,593 @@
-export declare const collectedComponentMetadata: Record<string, ComponentMetadata>;
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { DefaultToastOptions } from 'react-hot-toast';
+import { ErrorInfo } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { NavigateOptions } from 'react-router-dom';
+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 { 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;
+    /**
+     * 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;
+
+/**
+ * XMLUI keeps a registry of available actions to store information about out-of-the-box and custom
+ * actions (contributions implemented in external packages or files). This type describes the
+ * information the registry needs about the action to be able to render it.
+ */
+declare interface ActionRendererDef {
+    /**
+     * The name of the action that will be used to reference it in XMLUI.
+     */
+    actionName: string;
+    /**
+     * The function that executes the action.
+     */
+    actionFn: ActionFunction;
+}
+
+declare type AlignmentOptions = (typeof alignmentOptionValues)[number];
+
+declare const alignmentOptionValues: readonly ["start", "center", "end"];
+
+export 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;
+};
+
+/**
+ * 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 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 DateUtils: Record<string, any>;
+    readonly embed: {
+        isInIFrame: boolean;
+    };
+};
+
+/**
+ * This component runs the app in the context of the registered components
+ * (including the core xmlui components and external ones passed to this
+ * component.
+ */
+export declare function AppRoot({ apiInterceptor, contributes, node, decorateComponentsWithTestId, debugEnabled, defaultTheme, defaultTone, resources, globalProps, standalone, trackContainerHeight, routerBaseName, previewMode, servedFromSingleFile, resourceMap, sources, componentManager, }: AppWrapperProps & {
+    componentManager?: StandaloneComponentManager;
+}): JSX_2.Element;
+
+declare type AppWrapperProps = {
+    node: ComponentLike;
+    previewMode?: boolean;
+    servedFromSingleFile?: boolean;
+    routerBaseName?: string;
+    contributes?: ContributesDefinition;
+    globalProps?: GlobalProps;
+    resources?: Record<string, string>;
+    standalone?: boolean;
+    trackContainerHeight?: boolean;
+    decorateComponentsWithTestId?: boolean;
+    debugEnabled?: boolean;
+    apiInterceptor?: ApiInterceptorDefinition;
+    defaultTheme?: string;
+    defaultTone?: ThemeTone;
+    resourceMap?: Record<string, string>;
+    sources?: Record<string, string>;
+};
+
+declare interface ArrayDestructure extends DestructureBase {
+    type: "ADestr";
+}
+
+declare interface ArrayLiteral extends ExpressionBase {
+    type: "ALitE";
+    items: Expression[];
+    loose?: boolean;
+}
+
+declare interface ArrowExpression extends ExpressionBase {
+    type: "ArrowE";
+    name?: string;
+    args: Expression[];
+    statement: Statement;
+    closureContext?: BlockScope[];
+}
+
+declare interface ArrowExpressionStatement extends StatementBase {
+    type: "ArrowS";
+    expression: ArrowExpression;
+}
+
+declare interface AssignmentExpression extends ExpressionBase {
+    type: "AsgnE";
+    leftValue: Expression;
+    operator: AssignmentSymbols;
+    operand: 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 interface BaseNode {
+    /**
+     * Node type discriminator
+     */
+    type: Node_2["type"];
+    /**
+     * Start position (inclusive) of the node
+     */
+    startPosition?: number;
+    /**
+     * End position (exclusive)
+     */
+    endPosition?: number;
+    /**
+     * Start line number of the start token of the node
+     */
+    startLine?: number;
+    /**
+     * End line number of the end token of the node
+     */
+    endLine?: number;
+    /**
+     * Start column number (inclusive) of the node
+     */
+    startColumn?: number;
+    /**
+     * End column number (exclusive) of the node
+     */
+    endColumn?: number;
+    /**
+     * The source code of the expression
+     */
+    source?: string;
+    /**
+     * The start token of the node
+     */
+    startToken?: Token;
+    /**
+     * The end token of the node
+     */
+    endToken?: Token;
+}
+
+declare interface BinaryExpression extends ExpressionBase {
+    type: "BinaryE";
+    operator: BinaryOpSymbols;
+    left: Expression;
+    right: Expression;
+}
+
+declare type BinaryOpSymbols = "**" | "*" | "/" | "%" | "+" | "-" | "<<" | ">>" | ">>>" | "<" | "<=" | ">" | ">=" | "==" | "===" | "!=" | "!==" | "&" | "|" | "^" | "&&" | "||" | "??" | "in";
+
+declare type BlockScope = {
+    vars: Record<string, any>;
+    constVars?: Set<string>;
+    returnValue?: any;
+};
+
+declare interface BlockStatement extends StatementBase {
+    type: "BlockS";
+    statements: Statement[];
+}
+
+declare interface BreakStatement extends StatementBase {
+    type: "BrkS";
+}
+
+export 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;
+} & Pick<default_2.HTMLAttributes<HTMLButtonElement>, "className" | "aria-disabled" | "aria-label" | "aria-controls" | "aria-expanded" | "onClick" | "tabIndex" | "onFocus" | "onBlur" | "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 interface CalculatedMemberAccessExpression extends ExpressionBase {
+    type: "CMembE";
+    object: 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";
+};
+
+/**
+ * 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>;
+
+/**
+ * This interface represents the properties of a component definition.
+ */
+export 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>;
+}
+
+/**
+ * Sometimes, components and compound components can both be used
+ */
+export declare type ComponentLike = ComponentDef | CompoundComponentDef;
 
 /**
  * Components have metadata that the rendering engine uses to render the
@@ -65,29 +654,1295 @@ declare type ComponentPropertyMetadata = {
     isInternal?: boolean;
 };
 
-declare type DefaultThemeVars = Record<string | ThemeTone, string | Record<string, string>>;
+declare type ComponentRegisteredCallbackFn = (component: ComponentRendererDef) => void;
 
-declare type IsValidFunction<T> = (propKey: string, propValue: T) => string | string[] | undefined | null;
+declare interface ComponentRendererContextBase<TMd extends ComponentMetadata = ComponentMetadata> {
+    node: ComponentDef<TMd>;
+    state: ContainerState;
+    appContext?: AppContextObject;
+    renderChild: RenderChildFn;
+    layoutContext?: LayoutContext;
+}
 
 /**
- * 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.
+ * 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 PropertyValueDescription = string | number | {
-    value: string | number;
-    description: string;
+export 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;
 };
 
-declare type PropertyValueType = "boolean" | "string" | "number" | "any" | "ComponentDef";
+/**
+ * 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];
 
 /**
- * This type describes one the available theme tones.
+ * 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 type ThemeTone = (typeof ThemeToneKeys)[number];
+export 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: ComponentLike;
+    /**
+     * 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 interface ConditionalExpression extends ExpressionBase {
+    type: "CondE";
+    condition: Expression;
+    consequent: Expression;
+    alternate: Expression;
+}
+
+declare interface ConstStatement extends StatementBase {
+    type: "ConstS";
+    declarations: VarDeclaration[];
+    isExported?: boolean;
+}
 
 /**
- * Each theme can have a light or a dark tone.
+ * 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 const ThemeToneKeys: readonly ["light", "dark"];
+declare type ContainerState = Record<string | symbol, any>;
+
+declare interface ContinueStatement extends StatementBase {
+    type: "ContS";
+}
+
+/**
+ * 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[];
+    /**
+     * Action functions that come with the app.
+     */
+    actions?: ActionRendererDef[];
+    /**
+     * Application-specific compound components that come with the app.
+     */
+    compoundComponents?: CompoundComponentDef[];
+    /**
+     * Themes that come with the app.
+     */
+    themes?: ThemeDefinition_2[];
+};
+
+/**
+ * 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
+ */
+export declare function createComponentRenderer<TMd extends ComponentMetadata>(type: string, metadata: TMd, renderer: ComponentRendererFn<ComponentDef<TMd>>): ComponentRendererDef;
+
+export 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>>({ description, shortDescription, specializedFrom, status, props, events, contextVars, apis, nonVisual, opaque, themeVars, defaultThemeVars, toneSpecificThemeVars, allowArbitraryProps, docFolder, }: ComponentMetadata<TProps, TEvents, TContextVars, TApis>): ComponentMetadata<TProps, TEvents, TContextVars, TApis>;
+
+export declare function d(description: string, availableValues?: readonly PropertyValueDescription[], valueType?: PropertyValueType, defaultValue?: any, isValid?: IsValidFunction<any>): ComponentPropertyMetadata;
+
+declare type DefaultThemeVars = Record<string | ThemeTone_2, string | Record<string, string>>;
+
+declare type DefaultValueDescriptor = (string | ThemeIdDescriptor)[];
+
+declare interface Destructure extends DestructureBase {
+    type: "Destr";
+    arrayDestruct?: ArrayDestructure[];
+    objectDestruct?: ObjectDestructure[];
+}
+
+declare interface DestructureBase extends ExpressionBase {
+    id?: string;
+    arrayDestruct?: ArrayDestructure[];
+    objectDestruct?: ObjectDestructure[];
+}
+
+declare interface DoWhileStatement extends StatementBase {
+    type: "DoWS";
+    condition: 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 interface EmptyStatement extends StatementBase {
+    type: "EmptyS";
+}
+
+/**
+ * This component serves as an error boundary; it catches any errors within
+ * the nested components
+ */
+export 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.
+     */
+    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;
+    render(): string | number | boolean | Iterable<default_2.ReactNode> | JSX_2.Element;
+}
+
+declare type Expression = UnaryExpression | BinaryExpression | SequenceExpression | ConditionalExpression | FunctionInvocationExpression | MemberAccessExpression | CalculatedMemberAccessExpression | Identifier | Literal | ArrayLiteral | ObjectLiteral | SpreadExpression | AssignmentExpression | NoArgExpression | ArrowExpression | PrefixOpExpression | PostfixOpExpression | ReactiveVarDeclaration | VarDeclaration | Destructure | ObjectDestructure | ArrayDestructure | TemplateLiteralExpression;
+
+declare interface ExpressionBase extends BaseNode {
+    value?: any;
+    parenthesized?: number;
+    valueScope?: any;
+    valueIndex?: string | number;
+}
+
+declare interface ExpressionStatement extends StatementBase {
+    type: "ExprS";
+    expression: Expression;
+}
+
+/**
+ * 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 font-style value. Accepts two values to specify a range that is supported by a font-face,
+     * for example `font-style: 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;
+
+/**
+ * This type describes a font definition resource.
+ */
+declare type FontDef_2 = {
+    /**
+     * Specifies a name that will be used as the font face value for font properties
+     */
+    fontFamily: string;
+    /**
+     * A font-style value. Accepts two values to specify a range that is supported by a font-face,
+     * for example `font-style: 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 interface ForInStatement extends StatementBase {
+    type: "ForInS";
+    varBinding: ForVarBinding;
+    id: string;
+    expression: Expression;
+    body: Statement;
+    keys?: string[];
+    keyIndex?: number;
+}
+
+declare interface ForOfStatement extends StatementBase {
+    type: "ForOfS";
+    varBinding: ForVarBinding;
+    id: string;
+    expression: Expression;
+    body: Statement;
+    iterator?: any;
+}
+
+declare interface ForStatement extends StatementBase {
+    type: "ForS";
+    init?: ExpressionStatement | LetStatement;
+    condition?: Expression;
+    update?: Expression;
+    body: Statement;
+}
+
+declare type ForVarBinding = "let" | "const" | "none";
+
+declare interface FunctionDeclaration extends StatementBase {
+    type: "FuncD";
+    name?: string;
+    args: Expression[];
+    statement: BlockStatement;
+    isExported?: boolean;
+    closureContext?: BlockScope[];
+}
+
+declare interface FunctionInvocationExpression extends ExpressionBase {
+    type: "InvokeE";
+    object: Expression;
+    arguments: Expression[];
+}
+
+export declare function getColor(varName: string, format?: "hex" | "rgb" | "hsl"): string;
+
+declare type GlobalProps = Record<string, any>;
+
+export 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;
+    layout?: CSSProperties;
+}
+
+declare type IconPosition = (typeof iconPositionValues)[number];
+
+declare const iconPositionValues: readonly ["start", "end"];
+
+declare interface Identifier extends ExpressionBase {
+    type: "IdE";
+    name: string;
+    isGlobal?: boolean;
+}
+
+declare interface IfStatement extends StatementBase {
+    type: "IfS";
+    condition: Expression;
+    thenBranch: Statement;
+    elseBranch?: Statement;
+}
+
+declare interface ImportDeclaration extends StatementBase {
+    type: "ImportD";
+    imports: Record<string, string>;
+    moduleFile: string;
+    module?: ScriptModule | null;
+}
+
+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 interface LetStatement extends StatementBase {
+    type: "LetS";
+    declarations: VarDeclaration[];
+}
+
+declare interface Literal extends ExpressionBase {
+    type: "LitE";
+    value: 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;
+};
+
+/**
+ * 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 interface MemberAccessExpression extends ExpressionBase {
+    type: "MembE";
+    object: Expression;
+    member: string;
+    isOptional?: boolean;
+}
+
+declare type Message = ValueOrFunction<Renderable, Toast>;
+
+/**
+ * Represents a module error
+ */
+declare type ModuleErrors = Record<string, ScriptParserErrorMessage[]>;
+
+declare interface NoArgExpression extends ExpressionBase {
+    type: "NoArgE";
+}
+
+declare type Node_2 = Statement | Expression | SwitchCase;
+
+declare type NonCssLayoutProps = {
+    horizontalAlignment?: string;
+    verticalAlignment?: string;
+    orientation?: string;
+};
+
+declare interface ObjectDestructure extends DestructureBase {
+    type: "ODestr";
+    id: string;
+    alias?: string;
+}
+
+declare interface ObjectLiteral extends ExpressionBase {
+    type: "OLitE";
+    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
+ */
+export declare function parseScssVar(scssStr: any): any;
+
+declare interface PostfixOpExpression extends ExpressionBase {
+    type: "PostfE";
+    operator: PrefixOpSymbol;
+    operand: Expression;
+}
+
+declare interface PrefixOpExpression extends ExpressionBase {
+    type: "PrefE";
+    operator: PrefixOpSymbol;
+    operand: Expression;
+}
+
+declare type PrefixOpSymbol = "++" | "--";
+
+/**
+ * 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";
+
+/**
+ * This type represents the properties of the error boundary
+ */
+declare interface Props {
+    /**
+     * Child nodes within the boundary
+     */
+    children: ReactNode;
+    /**
+     * Whenever the value of this property changes, the boundary restores its "no error" state.
+     */
+    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 interface ReactiveVarDeclaration extends ExpressionBase {
+    type: "RVarD";
+    id: string;
+    expression: Expression;
+}
+
+/**
+ * This type represents a function that registers all API endpoints of a particular component.
+ */
+export 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>>) => ReactNode | ReactNode[];
+
+/**
+ * This interface defines the renderer context for the exposed components of the XMLUI framework.
+ */
+export declare interface RendererContext<TMd extends 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;
+    layoutNonCss: NonCssLayoutProps;
+}
+
+declare interface ReturnStatement extends StatementBase {
+    type: "RetS";
+    expression?: Expression;
+}
+
+declare type SchemaDescriptor = {
+    tables: Array<TableDescriptor>;
+    relationships?: any;
+    dtos?: any;
+};
+
+/**
+ * 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;
+}
+
+/**
+ * Represents a parsed and resolved module
+ */
+declare type ScriptModule = {
+    type: "ScriptModule";
+    name: string;
+    parent?: ScriptModule | null;
+    exports: Map<string, any>;
+    imports: Record<string, Record<string, any>>;
+    importedModules: ScriptModule[];
+    functions: Record<string, FunctionDeclaration>;
+    statements: Statement[];
+    executed: boolean;
+};
+
+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 interface SequenceExpression extends ExpressionBase {
+    type: "SeqE";
+    expressions: Expression[];
+    loose?: boolean;
+}
+
+declare const sizeValues: string[];
+
+export 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 interface SpreadExpression extends ExpressionBase {
+    type: "SpreadE";
+    operand: Expression;
+}
+
+export 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.
+ */
+export declare function StandaloneApp({ appDef, decorateComponentsWithTestId, debugEnabled, runtime, components: customComponents, componentManager, }: StandaloneAppProps): JSX_2.Element;
+
+export 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;
+    components?: ComponentRendererDef[];
+    componentManager?: StandaloneComponentManager;
+};
+
+/**
+ * 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 StandaloneComponentManager {
+    subscriptions: Set<ComponentRegisteredCallbackFn>;
+    registeredComponents: Array<ComponentRendererDef>;
+    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: ComponentRegisteredCallbackFn): 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: ComponentRegisteredCallbackFn): void;
+    /**
+     * Use this function to add a new component to the registry. Adding a new
+     * component will invoke all callbacks that have already subscribed to the
+     * component registration.
+     * @param component The component to register. You can pass a single
+     * component or an array of components.
+     */
+    registerComponent(component: ComponentRendererDef | ComponentRendererDef[]): void;
+}
+
+export 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
+ */
+export declare function startApp(runtime: any, components: ComponentRendererDef[] | undefined, componentManager: StandaloneComponentManager): Root;
+
+/**
+ * This type represents the current state of the error boundary
+ */
+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 | ImportDeclaration;
+
+declare interface StatementBase extends BaseNode {
+    guard?: boolean;
+    removeBlockScope?: boolean;
+    completeTryBlock?: boolean;
+    completeCatchBlock?: boolean;
+    completeFinallyBlock?: boolean;
+}
+
+declare interface SwitchCase extends BaseNode {
+    type: "SwitchC";
+    caseExpression?: Expression;
+    statements?: Statement[];
+}
+
+declare interface SwitchStatement extends StatementBase {
+    type: "SwitchS";
+    expression: Expression;
+    cases: SwitchCase[];
+}
+
+/**
+ * XMLUI executes some code synchronously. This type defines those functions' signature
+ */
+declare type SyncFunction = (...args: any) => any;
+
+declare type TableDescriptor = {
+    name: string;
+    fields?: Record<string, any>;
+    pk: Array<string>;
+    indexes?: Array<string>;
+};
+
+declare interface TemplateLiteralExpression extends ExpressionBase {
+    type: "TempLitE";
+    segments: (Literal | Expression)[];
+}
+
+/**
+ * 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.
+ */
+export 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>;
+}
+
+/**
+ * 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_2 extends ThemeDefinitionDetails_2 {
+    /**
+     * 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_2, ThemeDefinitionDetails_2>;
+}
+
+declare interface ThemeDefinitionDetails {
+    themeVars?: Record<string, string>;
+    resources?: Record<string, string | FontDef>;
+}
+
+declare interface ThemeDefinitionDetails_2 {
+    themeVars?: Record<string, string>;
+    resources?: Record<string, string | FontDef_2>;
+}
+
+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-align-vertical-Text-sub": "sub";
+     * "--xmlui-color-bg": "var(--xmlui-color-surface-50)"
+     */
+    themeStyles: Record<string, string>;
+    /**
+     * This hash object stores the theme variable names with their CSS values definition, like
+     * "align-vertical-Text-sub": "sub"; "color-bg": "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];
+
+/**
+ * This type describes one the available theme tones.
+ */
+declare type ThemeTone_2 = (typeof ThemeToneKeys_2)[number];
+
+/**
+ * Each theme can have a light or a dark tone.
+ */
+declare const ThemeToneKeys: readonly ["light", "dark"];
+
+/**
+ * Each theme can have a light or a dark tone.
+ */
+declare const ThemeToneKeys_2: readonly ["light", "dark"];
+
+declare interface ThrowStatement extends StatementBase {
+    type: "ThrowS";
+    expression: Expression;
+}
+
+declare type ToastHandler = (message: Message, options?: ToastOptions) => string;
+
+/**
+ * Converts the specified themeID to a CSS var string
+ * @param c segment to convert
+ */
+export declare function toCssVar(c: string | ThemeIdDescriptor): string;
+
+declare type Token = {
+    readonly text: string;
+    readonly type: TokenType;
+    readonly location: TokenLocation;
+};
+
+declare interface TokenLocation {
+    readonly startPosition: number;
+    readonly endPosition: number;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly startColumn: number;
+    readonly endColumn: number;
+}
+
+declare const 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,
+    Export = 96,
+    Import = 97,
+    As = 98,
+    From = 99
+}
+
+export 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 interface TryStatement extends StatementBase {
+    type: "TryS";
+    tryBlock: BlockStatement;
+    catchBlock?: BlockStatement;
+    catchVariable?: string;
+    finallyBlock?: BlockStatement;
+}
+
+declare interface UnaryExpression extends ExpressionBase {
+    type: "UnaryE";
+    operator: UnaryOpSymbols;
+    operand: 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;
+
+export declare function useColors(...colorNames: (string | ColorDef)[]): Record<string, string>;
+
+export 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
+     */
+    asOptionalString(expression?: any): string | undefined;
+    /**
+     * Get an optional string value from an expression
+     * @param expression Value expression
+     */
+    asOptionalStringArray(expression?: any): string[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Get a CSS size value from an expression
+     * @param expression Value expression
+     */
+    asSize(expression?: any): string;
+};
+
+declare interface VarDeclaration extends ExpressionBase {
+    type: "VarD";
+    id?: string;
+    arrayDestruct?: ArrayDestructure[];
+    objectDestruct?: ObjectDestructure[];
+    expression?: Expression;
+}
+
+declare interface VarStatement extends StatementBase {
+    type: "VarS";
+    declarations: ReactiveVarDeclaration[];
+}
+
+declare interface WhileStatement extends StatementBase {
+    type: "WhileS";
+    condition: Expression;
+    body: Statement;
+}
 
 export { }
+
+
+declare module "@tanstack/table-core" {
+    interface TableMeta<TData extends RowData> {
+        cellRenderer: (...args: any[]) => any;
+    }
+    interface ColumnMeta<TData extends RowData, TValue> {
+        style?: CSSProperties;
+        starSizedWidth?: string;
+        accessorKey?: string;
+        pinTo?: string;
+        cellRenderer?: (row: any) => ReactNode;
+    }
+}
+
+
+declare global {
+    interface Window {
+        TEST_ENV: StandaloneAppDescription | undefined;
+    }
+}