xmlui 0.4.0

package/dist/xmlui.es.d.ts

@@ -0,0 +1,1667 @@
+import { CSSProperties } from 'react';
+import type { DefaultToastOptions } from 'react-hot-toast';
+import { ErrorInfo } from 'react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import type { NavigateOptions } from 'react-router-dom';
+import type { QueryClient } from '@tanstack/react-query';
+import { default as React_2 } from 'react';
+import { default as ReactDOM_2 } from 'react-dom/client';
+import { ReactNode } from 'react';
+import type { Renderable } from 'react-hot-toast';
+import type { To } from 'react-router-dom';
+import type { Toast } from 'react-hot-toast';
+import type { ToastOptions } from 'react-hot-toast';
+import type { 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 = "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>;
+    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;
+    /**
+     * Navigate from the current location to the specified one using the given options.
+     * @param to New app location
+     * @param options Navigation options
+     */
+    readonly navigate: (to: To, options?: NavigateOptions) => void;
+    /**
+     * Display a confirmation dialog in the UI and retrieve the confirmation result.
+     * @param title Dialog title
+     * @param message Confirmation message
+     * @param actionMessage Optional action message
+     * @return True, if the user confirmed the action; otherwise, false.
+     */
+    readonly confirm: (title: string, message?: string, actionMessage?: string) => Promise<boolean>;
+    /**
+     * Get the information about the logged-in user. If null, no user is logged in.
+     */
+    readonly loggedInUser: LoggedInUserDto | null;
+    readonly setLoggedInUser: (loggedInUser: any) => void;
+    /**
+     * The `QueryClient` object of the react-query library AppEngine uses for data fetching purposes
+     */
+    readonly queryClient: QueryClient | null;
+    /**
+     * The base name of the router
+     */
+    readonly routerBaseName: string;
+    /**
+     * Get an unformatted Date string that is JSON friendly.
+     * If no input param is set, use the current date time.
+     * @param date Potential Date string
+     */
+    readonly isoDateString: (date?: string) => string;
+    /**
+     * A function that formats a date value to a string
+     * @param date Date to format
+     */
+    readonly formatDate: (date: string | Date) => string | undefined;
+    /**
+     * A function that formats a date and time value to a string
+     * @param date Date to format
+     */
+    readonly formatDateTime: (date: any) => string | undefined;
+    /**
+     * A function that formats a time value to a string
+     * @param date Date to format
+     */
+    readonly formatTime: (date: any) => string | undefined;
+    /**
+     * A function that formats a file size number to a friendly string
+     * @param bytes Number of bytes to format
+     */
+    readonly formatFileSizeInBytes: (bytes: number) => string | undefined;
+    /**
+     * A function that retrieves the extension of the specified file name
+     * @param fileName Filename to check for extension
+     */
+    readonly getFileExtension: (fileName: string) => string | undefined;
+    /**
+     * Indicates that the root component represents a standalone application that runs without interacting with the
+     * storage engine.
+     */
+    readonly standalone?: boolean;
+    readonly decorateComponentsWithTestId?: boolean;
+    readonly signError: (error: Error | string) => void;
+    readonly 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>;
+    };
+    readonly activeThemeUid: string;
+    readonly availableThemeUids: string[];
+    readonly setTheme: (newTheme: string) => void;
+    readonly globals?: Record<string, any>;
+    readonly resources?: Record<string, string>;
+    readonly apiInterceptorContext: IApiInterceptorContext;
+    readonly formatTimeWithoutSeconds: (date: string | Date) => string | undefined;
+    readonly formatDateWithoutYear: (date: string | Date) => string | undefined;
+    readonly smartFormatDateTime: (date: string | Date) => string | undefined;
+    readonly smartFormatDate: (date: string | Date) => string | undefined;
+    readonly capitalize: (s?: string) => string;
+    readonly pluralize: (number: number, singular: string, plural: string) => string;
+    readonly delay: (timeInMs: number, callback?: any) => Promise<void>;
+    readonly getDate: () => Date;
+    readonly getDateUntilNow: (date?: string | number | Date, nowLabel?: string, time?: string) => string;
+    readonly Actions: Record<string, ActionFunction>;
+    readonly Transforms: Record<string, any>;
+    readonly Utils: Record<string, any>;
+    readonly DateUtils: Record<string, any>;
+    readonly embed: {
+        isInIFrame: boolean;
+    };
+    readonly environment: {
+        isWindowFocused: boolean;
+    };
+    readonly mediaSize: {
+        phone: boolean;
+        tablet: boolean;
+        desktop: boolean;
+        smallScreen: boolean;
+        largeScreen: boolean;
+    };
+};
+
+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";
+    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: React_2.ForwardRefExoticComponent<{
+    id?: string;
+    type?: ButtonType;
+    variant?: ButtonVariant;
+    themeColor?: ButtonThemeColor;
+    size?: ButtonSize;
+    disabled?: boolean;
+    children?: React_2.ReactNode | React_2.ReactNode[];
+    icon?: React_2.ReactNode;
+    iconPosition?: IconPosition;
+    contentPosition?: AlignmentOptions;
+    orientation?: OrientationOptions;
+    formId?: string;
+    style?: CSSProperties;
+    gap?: string | number;
+    accessibilityProps?: any;
+    autoFocus?: boolean;
+    title?: string;
+} & Pick<React_2.HTMLAttributes<HTMLButtonElement>, "className" | "onClick" | "tabIndex" | "onFocus" | "onBlur" | ButtonAria> & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare type ButtonAria = "aria-controls" | "aria-expanded" | "aria-disabled" | "aria-label";
+
+declare type ButtonHintValueType = "ButtonType" | "ButtonVariant" | "ButtonThemeColor" | "ButtonSize";
+
+declare type ButtonSize = "xs" | "sm" | "md" | "lg";
+
+declare type ButtonThemeColor = "attention" | "primary" | "secondary";
+
+declare type ButtonType = "button" | "submit" | "reset";
+
+declare type ButtonVariant = "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";
+};
+
+/**
+ * XMLUI turns its markup into component definitions, simple data structures describing a component.
+ * When the engine renders these definitions, it turns them into React components.
+ *
+ * Components (like other concepts within the XMLUI framework) use properties and event handlers to do
+ * their job; thus, this interface extends `ObjectWithProps<T>`.
+ *
+ * We will refactor component script handling in the future and consider removing the `uses` property.
+ */
+export declare interface ComponentDef<T extends string = string> extends Scriptable {
+    type: T;
+    uid?: string;
+    testId?: string;
+    props?: Record<string, any>;
+    events?: Record<string, any>;
+    /**
+     * 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[];
+    /**
+     * 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 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<string, any>;
+    /**
+     * Components may provide context variables that can be used to in expressions and event handlers
+     * within the component.
+     */
+    contextVars?: 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[];
+}
+
+declare type ComponentDescriptor<T extends ComponentDef> = {
+    displayName?: string;
+    description?: string;
+    props?: PropertyComponentDescriptorHash<T>;
+    events?: EventDescriptorHash<T>;
+    nonVisual?: boolean;
+    opaque?: boolean;
+    themeVars?: Array<string>;
+    defaultThemeVars?: DefaultThemeVars;
+    toneSpecificThemeVars?: Record<string, Record<string, string>>;
+};
+
+/**
+ * Sometimes, components and compound components can both be used
+ */
+export declare type ComponentLike = ComponentDef | CompoundComponentDef;
+
+declare type ComponentPropertyDescriptor = {
+    displayName?: string;
+    category?: string;
+    description?: string;
+    valueType?: PropertyValueType;
+    availableValues?: any[];
+    defaultValue?: any;
+    isValid?: IsValidFunction<any>;
+};
+
+declare interface ComponentRendererContextBase<T extends ComponentDef = ComponentDef> {
+    node: T;
+    state: ContainerState;
+    appContext?: AppContextObject;
+    renderChild: RenderChildFn;
+    layoutCss: CSSProperties;
+    layoutNonCss: NonCssLayoutProps;
+    layoutContext?: LayoutContext;
+    dynamicChildren?: Array<DynamicChildComponentDef>;
+    childIndex?: number;
+}
+
+/**
+ * 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 = {
+    /**
+     * 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<any>;
+    /**
+     * The metadata to use when rendering the component
+     */
+    metadata?: ComponentDescriptor<any>;
+};
+
+/**
+ *
+ */
+declare type ComponentRendererFn<T extends ComponentDef> = (context: RendererContext<T>) => ReactNode;
+
+/**
+ * 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.
+ */
+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>;
+}
+
+declare interface ConditionalExpression extends ExpressionBase {
+    type: "CondE";
+    condition: Expression;
+    consequent: Expression;
+    alternate: Expression;
+}
+
+declare interface ConstStatement extends StatementBase {
+    type: "ConstS";
+    declarations: VarDeclaration[];
+    isExported?: boolean;
+}
+
+/**
+ * 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 interface ContinueStatement extends StatementBase {
+    type: "ContS";
+}
+
+declare type ContributesDefinition = {
+    components?: ComponentRendererDef[];
+    actions?: ActionRendererDef[];
+    compoundComponents?: CompoundComponentDef[];
+    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 hints 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<T extends ComponentDef>(type: T["type"], renderer: ComponentRendererFn<T>, hints?: ComponentDescriptor<T>): ComponentRendererDef;
+
+declare type DefaultThemeVars = Record<string | ThemeTone, 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 `ChildrenSlot`
+ * 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 React_2.Component<Props, State> {
+    /**
+     * We start with "no error" state
+     */
+    state: State;
+    /**
+     * This method is used to implement the Error Boundaries for the React application. It is invoked if some error
+     * occurs during the rendering phase of any lifecycle methods or any 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<React_2.ReactNode> | JSX_2.Element;
+}
+
+declare type EventDescriptorHash<T extends ComponentDef> = Partial<Record<keyof NonNullable<T["events"]>, ComponentPropertyDescriptor>>;
+
+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;
+
+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;
+
+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;
+
+/**
+ * This type represents an arbitrary set of global properties (name and value pairs).
+ */
+declare type GlobalProps = Record<string, any>;
+
+declare interface IApiInterceptorContext {
+    isMocked: (url: string) => boolean;
+}
+
+export declare const Icon: ({ name, fallback, layout, className, ...restProps }: IconBaseProps) => JSX_2.Element;
+
+declare interface IconBaseProps extends React_2.SVGAttributes<SVGElement> {
+    children?: React_2.ReactNode;
+    color?: string;
+    title?: string;
+    size?: string;
+    isInline?: boolean;
+    fallback?: string | React_2.ReactNode;
+    layout?: CSSProperties;
+}
+
+declare type IconPosition = "left" | "right" | "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?: ComponentDescriptor<T>) => ReactNode;
+    /**
+     * Arbitrary props extending the layout context
+     */
+    [key: string]: any;
+};
+
+declare type LayoutProps = {
+    horizontalAlignment?: string;
+    verticalAlignment?: string;
+    orientation?: string;
+    width?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    height?: number | string;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+    gap?: string;
+    top?: number | string;
+    right?: number | string;
+    bottom?: number | string;
+    left?: number | string;
+    border?: string;
+    borderTop?: string;
+    borderRight?: string;
+    borderBottom?: string;
+    borderLeft?: string;
+    radius?: number | string;
+    radiusTopLeft?: number | string;
+    radiusTopRight?: number | string;
+    radiusBottomLeft?: number | string;
+    radiusBottomRight?: number | string;
+    padding?: number | string;
+    horizontalPadding?: number | string;
+    verticalPadding?: number | string;
+    paddingTop?: number | string;
+    paddingRight?: number | string;
+    paddingBottom?: number | string;
+    paddingLeft?: number | string;
+    margin?: number | string;
+    horizontalMargin?: number | string;
+    verticalMargin?: number | string;
+    marginTop?: number | string;
+    marginRight?: number | string;
+    marginBottom?: number | string;
+    marginLeft?: number | string;
+    backgroundColor?: string;
+    background?: string;
+    shadow?: string;
+    direction?: string;
+    horizontalOverflow?: string;
+    verticalOverflow?: string;
+    zIndex?: number | string;
+    opacity?: string | number;
+    color?: string;
+    fontFamily?: string;
+    fontSize?: number | string;
+    fontWeight?: number | string;
+    italic?: boolean | string;
+    textDecoration?: string;
+    userSelect?: string;
+    letterSpacing?: string;
+    textTransform?: string;
+    lineHeight?: string;
+    textAlign?: string;
+    textWrap?: string;
+    textAlignLast?: string;
+    wrapContent?: boolean | string;
+    canShrink?: boolean | string;
+    cursor?: string;
+};
+
+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 = {
+    /**
+     * If we pass down an event handler to a component, we should sign the error once, only in some
+     * steps of the component chain. This property (by default, true) indicates this intention.
+     */
+    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 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<T extends ComponentDef = ComponentDef> = (eventName: keyof NonNullable<T["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 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[]>;
+
+/**
+ * A function that resolves a module name to the text of the module
+ */
+declare type ModuleResolver = (sourceModule: string, moduleName: string) => string | null;
+
+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])[];
+}
+
+/**
+ * This interface describes an AppEngine Splitter component.
+ */
+declare type Orientation = "horizontal" | "vertical";
+
+declare type OrientationOptions = "horizontal" | "vertical";
+
+export declare function parseXmlUiMarkup(source: string, moduleResolver?: ModuleResolver, useOldParser?: boolean): ComponentDef<string> | CompoundComponentDef;
+
+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 = "++" | "--";
+
+declare type PropertyComponentDescriptorHash<T extends ComponentDef> = Partial<Record<keyof NonNullable<T["props"]> | keyof LayoutProps, ComponentPropertyDescriptor>>;
+
+declare type PropertyValueType = "boolean" | "string" | "number" | "numberOrString" | "OrientationOptions" | "AlignmentOptions" | "UserSelectOptions" | "DirectionOptions" | "ScrollingOptions" | "CssFontFamily" | "CssFontWeight" | "CssSize" | "CssOpacity" | "CssBorder" | "CssRadius" | "CssColor" | "CssShadow" | "CssTextDecoration" | "ActionSet" | "CssColorType" | "ComponentDef" | "ComponentDef[]" | "ComponentDefMap" | "IconPosition" | "CssUnit" | "TextTransformOptions" | "TextWrapOptions" | "Option[] | string[]" | "FieldValidator[]" | "SearchBoxDef" | TypographyHintValueType | ButtonHintValueType | "any";
+
+/**
+ * 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;
+    layout?: 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.
+ */
+declare type RegisterComponentApiFn = (apiFn: Record<string, (...args: any[]) => void>) => void;
+
+declare type RenderChildFn<L extends ComponentDef = ComponentDef> = (children?: ComponentDef | ComponentDef[] | DynamicChildComponentDef | DynamicChildComponentDef[] | string, layoutContext?: LayoutContext<L>, childrenToRender?: DynamicChildComponentDef[]) => ReactNode | ReactNode[];
+
+/**
+ * This interface defines the renderer context for the exposed components of the XMLUI framework.
+ */
+declare interface RendererContext<T extends ComponentDef> extends ComponentRendererContextBase<T> {
+    /**
+     * 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<T>;
+    /**
+     * 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;
+}
+
+declare interface ReturnStatement extends StatementBase {
+    type: "RetS";
+    expression?: Expression;
+}
+
+export declare function RootComponent({ apiInterceptor, contributes, node, decorateComponentsWithTestId, defaultTheme, defaultTone, resources, globalProps, standalone, baseName, previewMode, servedFromSingleFile, resourceMap, }: RootComponentProps): JSX_2.Element;
+
+/**
+ * The properties of the root component
+ */
+declare type RootComponentProps = {
+    /**
+     * View component definition
+     */
+    node: ComponentLike;
+    /**
+     * Display the component in preview mode?
+     */
+    previewMode?: boolean;
+    servedFromSingleFile?: boolean;
+    /**
+     * The name used as the base name in the router definition
+     */
+    baseName?: string;
+    /**
+     * An object that describes how other external components extend the application with external components
+     */
+    contributes: ContributesDefinition;
+    /**
+     * Arbitrary set of global properties
+     */
+    globalProps?: GlobalProps;
+    resources?: Record<string, string>;
+    /**
+     * Indicates that the root component represents a standalone application
+     */
+    standalone?: boolean;
+    decorateComponentsWithTestId?: boolean;
+    apiInterceptor?: ApiInterceptorDefinition;
+    defaultTheme?: string;
+    defaultTone?: ThemeTone;
+    resourceMap?: Record<string, string>;
+};
+
+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, 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";
+
+declare interface SequenceExpression extends ExpressionBase {
+    type: "SeqE";
+    expressions: Expression[];
+    loose?: boolean;
+}
+
+declare type SplitProps = {
+    /**
+     * The children to display in the splitter.
+     */
+    children: React_2.ReactNode[] | React_2.ReactNode;
+    /**
+     * The layout of the splitter.
+     */
+    layout?: React_2.CSSProperties;
+    /**
+     * The template to display in the splitter.
+     */
+    splitterTemplate?: React_2.ReactNode;
+    /**
+     * The orientation of the splitter.
+     * The default is "horizontal".
+     */
+    orientation?: Orientation;
+    /**
+     * Whether the splitter is floating.
+     */
+    floating?: boolean;
+    /**
+     * A callback that is called when the splitter is resized.
+     */
+    resize?: (sizes: [number, number]) => void;
+    /**
+     * Whether the primary and secondary panes are swapped.
+     */
+    swapped?: boolean;
+    /**
+     * The initial width/height of the left/top pane.
+     * Width is specified as a CSS unit (e.g. %, fr, px).
+     * The default is 50%.
+     */
+    initialPrimarySize?: string;
+    /**
+     * The preferred minimum width/height of the left/top pane.
+     * Specified as a CSS unit (e.g. %, fr, px).
+     * The default is 0.
+     */
+    minPrimarySize?: string;
+    /**
+     * The preferred maximum width/height of the left/top pane.
+     */
+    maxPrimarySize?: string;
+};
+
+export declare const Splitter: ({ initialPrimarySize, minPrimarySize, maxPrimarySize, orientation, children, layout, swapped, floating, splitterTemplate, resize, }: SplitProps) => JSX_2.Element;
+
+declare interface SpreadExpression extends ExpressionBase {
+    type: "SpreadE";
+    operand: Expression;
+}
+
+export declare const Stack: React_2.ForwardRefExoticComponent<Props_2 & React_2.RefAttributes<any>>;
+
+export declare function StandaloneApp({ appDef, decorateComponentsWithTestId, runtime, components: customComponents, }: 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>;
+    globals?: Record<string, any>;
+    apiInterceptor?: ApiInterceptorDefinition;
+};
+
+declare type StandaloneAppProps = {
+    appDef?: StandaloneAppDescription;
+    decorateComponentsWithTestId?: boolean;
+    runtime?: any;
+    components?: ComponentRendererDef[];
+};
+
+export declare type StandaloneJsonConfig = {
+    name?: string;
+    globals?: Record<string, any>;
+    entryPoint?: string;
+    components?: string[];
+    themes?: string[];
+    defaultTheme?: string;
+    resources?: Record<string, string>;
+    resourceMap?: Record<string, string>;
+    apiInterceptor?: ApiInterceptorDefinition;
+};
+
+export declare function startApp(runtime: any, components?: ComponentRendererDef[]): ReactDOM_2.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>;
+};
+
+/**
+ * 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>;
+}
+
+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-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];
+
+/**
+ * Each theme can have a light or a dark tone.
+ */
+declare const ThemeToneKeys: 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,
+    Arrow = 59,
+    DecimalLiteral = 60,
+    HexadecimalLiteral = 61,
+    BinaryLiteral = 62,
+    RealLiteral = 63,
+    StringLiteral = 64,
+    Infinity = 65,
+    NaN = 66,
+    True = 67,
+    False = 68,
+    Typeof = 69,
+    Null = 70,
+    Undefined = 71,
+    In = 72,
+    Let = 73,
+    Const = 74,
+    Var = 75,
+    If = 76,
+    Else = 77,
+    Return = 78,
+    Break = 79,
+    Continue = 80,
+    Do = 81,
+    While = 82,
+    For = 83,
+    Of = 84,
+    Try = 85,
+    Catch = 86,
+    Finally = 87,
+    Throw = 88,
+    Switch = 89,
+    Case = 90,
+    Default = 91,
+    Delete = 92,
+    Function = 93,
+    Export = 94,
+    Import = 95,
+    As = 96,
+    From = 97
+}
+
+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 type TypographyHintValueType = "HeadingLevel" | "TextVariant";
+
+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) => 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 { }