xmlui 0.9.59 → 0.9.61

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

@@ -19,35 +19,16 @@ import { Toast } from 'react-hot-toast';
 import { ToastOptions } from 'react-hot-toast';
 import { ValueOrFunction } from 'react-hot-toast';
 
-/**
- * This type represents the context in which an action is executed.
- */
 declare interface ActionExecutionContext {
-    /**
-     * A unique identifier for the container that the action is executed in.
-     */
     uid: symbol;
-    /**
-     * The state of the container that the action is executed in.
-     */
     state: ContainerState;
     getCurrentState: () => ContainerState;
-    /**
-     * The appContext object passed to the current app
-     */
     appContext: AppContextObject;
-    /**
-     * The lookup function to resolve a sync action by its name.
-     */
     lookupAction: LookupAsyncFnInner;
     navigate: any;
     location: any;
 }
 
-/**
- * This type represents a function that executes a particular action within the specified context
- * using the given arguments.
- */
 declare type ActionFunction = (executionContext: ActionExecutionContext, ...args: any[]) => any;
 
 declare type AlignmentOptions = (typeof alignmentOptionValues)[number];
@@ -74,196 +55,45 @@ declare function ApiInterceptorProvider({ interceptor, children, apiWorker, useH
     waitForApiInterceptor?: boolean;
 }): JSX_2.Element;
 
-/**
- * This interface defines the properties and services of an app context that the application components can use when
- * implementing their behavior.
- */
 declare type AppContextObject = {
-    /**
-     * Accept other methods
-     */
     [x: string]: unknown;
     version: string;
     Actions: Record<string, ActionFunction>;
-    /* Excluded from this release type: apiInterceptorContext */
-    /**
-     * This property returns a hash object containing all application-global settings
-     * defined in the app's configuration file.
-     */
+    apiInterceptorContext: IApiInterceptorContext;
     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.
-     */
+    debugEnabled?: boolean;
+    decorateComponentsWithTestId?: boolean;
     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`.
-     */
+    queryClient: QueryClient | null;
     standalone?: boolean;
-    /**
-     * This function formats the specified value's date part into a local date string
-     * (according to the machine's local settings).
-     * @param date Date to format
-     */
     formatDate: (date: string | Date) => string | undefined;
-    /**
-     * This function formats the specified value into a local
-     * date and time string (according to the machine's local settings).
-     * @param date Date to format
-     */
     formatDateTime: (date: any) => string | undefined;
-    /**
-     * This function formats the specified value's date part (without year)
-     * into a local date string (according to the machine's local settings).
-     * @param date Date to format
-     */
     formatDateWithoutYear: (date: string | Date) => string | undefined;
-    /**
-     * This function formats the specified value's time part into a local date
-     * string (according to the machine's local settings).
-     * @param date Date to format
-     */
     formatTime: (date: any) => string | undefined;
-    /**
-     * This function formats the specified value's time part (without seconds)
-     * into a local date string (according to the machine's local settings).
-     * @param date Date to format
-     */
     formatTimeWithoutSeconds: (date: string | Date) => string | undefined;
-    /**
-     * This function creates a date from the specified input value. If no input
-     *  is provided, it returns the current date and time.
-     */
     getDate: (date?: string | number | Date) => Date;
-    /**
-     * This function calculates the difference between the current date and the
-     * provided one and returns it in a human-readable form, such as "1 month", "2 weeks", etc.
-     * @param date
-     * @param nowLabel
-     * @param time
-     * @returns
-     */
     getDateUntilNow: (date?: string | number | Date, nowLabel?: string, time?: string) => string;
-    /**
-     * This function converts the input string into a date value and returns
-     * the ISO 8601 string representation of the date. It can pass dates between
-     * the UI and backend APIs in a standard format.
-     * @param date Date to format
-     */
     isoDateString: (date?: string) => string;
-    /**
-     * This function checks if the specified date is today.
-     * @param date Date to check
-     */
     isToday: (date: string | Date) => boolean;
-    /**
-     * This function checks if the specified date is tomorrow.
-     * @param date Date to check
-     */
     isTomorrow: (date: string | Date) => boolean;
-    /**
-     * This function checks if the specified date is yesterday.
-     * @param date Date to check
-     */
     isYesterday: (date: string | Date) => boolean;
-    /**
-     * This function checks the date value provided for some particular
-     * values and returns accordingly. Otherwise, returns it as `formatDate` would.
-     * @param date Date to format
-     */
     smartFormatDate: (date?: string | number | Date) => string;
-    /**
-     * This function checks the date value provided for some particular values and
-     * returns accordingly. Otherwise, returns it as `formatDateTime` would.
-     * @param date Date to format
-     */
     smartFormatDateTime: (date: string | Date) => string | undefined;
-    /**
-     * This functions creates the difference between two dates in minutes.
-     * @param date1 First date
-     * @param date2 Second date
-     * @returns The difference in minutes
-     */
     differenceInMinutes: (date1: number | Date, date2: number | Date) => number;
-    /**
-     * This function checks if the specified dates are on the same day.
-     * @param dateLeft First date
-     * @param dateRight Second Date
-     * @returns True, if the dates are on the same day; otherwise, false.
-     */
     isSameDay: (dateLeft: number | Date, dateRight: number | Date) => boolean;
-    /**
-     * This function checks if the specified date is in the current calendar year.
-     * @param date Date to check
-     * @returns True, if the date is in the current year; otherwise, false.
-     */
     isThisYear: (date: Date | number) => boolean;
-    /**
-     * Formats a date into a human-readable elapsed time string.
-     * @param date Date to format
-     * @returns Returns strings like "now", "12 seconds ago", "3 hours ago",
-     * "today", "yesterday", "3 weeks ago", etc.
-     */
     formatHumanElapsedTime: (date: string | Date) => string;
-    /**
-     * 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;
@@ -278,43 +108,13 @@ declare type AppContextObject = {
             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;
@@ -405,10 +205,6 @@ declare interface AssignmentExpression extends ExpressionBase {
 
 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 = {
@@ -523,104 +319,32 @@ declare type ComponentCompilation = CompilationUnit & {
     definition: CompoundComponentDef;
 };
 
-/**
- * This interface represents the properties of a component definition.
- */
 declare interface ComponentDef<TMd extends ComponentMetadata = ComponentMetadata> extends ComponentDefCore, Scriptable {
     props?: Record<keyof TMd["props"], any>;
     events?: Record<keyof TMd["events"], any>;
-    /**
-     * Components may have an API that other components can use to interact with them. This property holds
-     * the API methods associated with this component definition.
-     */
     api?: Record<keyof TMd["apis"], any>;
-    /**
-     * Components may provide context variables that can be used to in expressions and event handlers
-     * within the component.
-     * REVIEW: This property can be removed after migration to the new componend definition type.
-     */
     contextVars?: Record<keyof TMd["contextVars"], string>;
 }
 
-/**
- * This interface represents the core properties of a component definition (independent
- * of component metadata).
- */
 declare interface ComponentDefCore {
     type: string;
     uid?: string;
     testId?: string;
-    /**
-     * A component can define namespaces on it, with the <ComponentName xmlns:KEY="VALUE" /> syntax
-     * these are used later to resolve the `type` of the componentDef.
-     * <KEY:Button/> will have type `VALUE.Button` (joined with a "." (dot) )
-     */
     namespaces?: Record<string, string>;
-    /**
-     * Though components manage their state internally, the app logic may require user state management.
-     * Components may have user *variables*, which the UI logic uses to manage the application state.
-     * This property holds the variables (name and value pairs) associated with this component definition.
-     */
     vars?: Record<string, any>;
-    /**
-     * Each component may have child components to constitute a hierarchy of components. This property
-     * holds the definition of these nested children.
-     */
     children?: ComponentDef[];
-    /**
-     * Components may have slots that can be filled with other components. This property holds the
-     * contents of the slots
-     */
     slots?: Record<string, ComponentDef[]>;
-    /**
-     * This property is evaluated to a Boolean value during run time. When this value is `true`, the
-     * component with its children chain is rendered; otherwise, the entire component hierarchy is omitted
-     * from the rendered tree.
-     */
     when?: string | boolean;
-    /**
-     * Some components work with data obtained asynchronously. Fetching this data requires some state
-     * management handling the complexity (including error handling) of data access. A *loader* is
-     * responsible for managing this logic. This property holds the loaders associated with this component
-     * definition.
-     */
     loaders?: ComponentDef[];
-    /**
-     * Components may have functions that are used to perform some logic. This property holds the functions
-     * (name and function body) associated with this component definition.
-     */
     functions?: Record<string, any>;
-    /**
-     * Components managing state through variables or loaders are wrapped with containers responsible
-     * for this job. Just as components, containers form a hierarchy. While working with this hierarchy,
-     * parent components may flow state values (key and value pairs) to their child containers. This
-     * property holds the name of state values to flow down to the direct child containers.
-     */
     uses?: string[];
-    /**
-     * Arbitrary debug information that can be attached to a component definition.
-     * Current usage:
-     * - `debug: { source: { start: number, end: number } }` Ther start and end positions of of the source
-     *   belonging to the particular component definition.
-     */
     debug?: Record<string, any>;
 }
 
 declare type ComponentExtension = ComponentRendererDef | CompoundComponentDef;
 
-/**
- * Sometimes, components and compound components can both be used
- */
 declare type ComponentLike = ComponentDef | CompoundComponentDef;
 
-/**
- * Components have metadata that the rendering engine uses to render the
- * component. This type defines the structure of such metadata.
- *
- * The type has generic parameters to ensure that type-checking works with
- * the metadata defined here in concert with the renderer object using the
- * same metadata type.
- */
 declare type ComponentMetadata<TProps extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TEvents extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TContextValues extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TApis extends Record<string, ComponentPropertyMetadata> = Record<string, any>> = {
     status?: "stable" | "experimental" | "deprecated" | "in progress";
     description?: string;
@@ -643,46 +367,13 @@ declare type ComponentMetadata<TProps extends Record<string, ComponentPropertyMe
     isHtmlTag?: boolean;
 };
 
-/**
- * Components have properties, events, context values, and exposed API
- * endpoints, each holding metadata the rendering engine uses at run time.
- * This type defines the structure of such metadata.
- */
 declare type ComponentPropertyMetadata = {
-    /**
-     * This field defines the description explaining the property. You can use
-     * markdown, as the UI may display this value.
-     */
     readonly description: string;
-    /**
-     * This field defines the type of the property. The rendering engine uses this
-     * information to validate the property value.
-     */
     readonly valueType?: PropertyValueType;
-    /**
-     * This field defines the available values of the property. The rendering engine
-     * uses this information to validate the property value.
-     */
     readonly availableValues?: readonly PropertyValueDescription[];
-    /**
-     * This field defines the default value of the property. The rendering engine uses
-     * this information to set the default value of the property.
-     */
     defaultValue?: any;
-    /**
-     * This field defines a validation function that the rendering engine uses to validate
-     * the property value. The function returns one or more hinst if the property value is
-     * invalid.
-     */
     isValid?: IsValidFunction<any>;
-    /**
-     * Indicates that a particular property is internal and should not be exposed in the
-     * documentation
-     */
     isInternal?: boolean;
-    /**
-     * Indicates that a particular property is required for the component to essentially function.
-     */
     isRequired?: boolean;
 };
 
@@ -694,69 +385,22 @@ declare interface ComponentRendererContextBase<TMd extends ComponentMetadata = C
     layoutContext?: LayoutContext;
 }
 
-/**
- * Components must be registered with a component registry so the engine can use them. This type
- * collects the information held by the registry.
- */
 declare type ComponentRendererDef<T extends ComponentDef = any> = {
-    /**
-     * The component's type identifier. In the markup, the component must use this name to be recognized.
-     */
     type: string;
-    /**
-     * This function renders the component from its definition to its React representation.
-     */
     renderer: ComponentRendererFn<T>;
-    /**
-     * The metadata to use when rendering the component
-     */
     metadata?: ComponentMetadata;
 };
 
-/**
- * This function renders a component definition into a React component
- */
 declare type ComponentRendererFn<T extends ComponentDef> = (context: RendererContext<T>) => ReactNode;
 
 declare type ComponentSize = (typeof sizeValues)[number];
 
-/**
- * XMLUI allows the creation of reusable components assembled from other XMLUI components (with markup).
- * This type represents such components. The name `CompoundComponent` refers to the assembled nature
- * of reusable components.
- */
 declare interface CompoundComponentDef extends Scriptable {
-    /**
-     * Each compound component must have a unique name. The markup uses this name to refer to the
-     * particular compound component.
-     */
     name: string;
-    /**
-     * Each compound component must have a single root component defining the component contents.
-     */
     component: ComponentDef;
-    /**
-     * Compound components may provide an API that other components can use to interact with them. This
-     * property holds the API methods associated with this compound component definition.
-     */
     api?: Record<string, any>;
-    /**
-     * This property holds the variables (name and value pairs) associated with this compound component
-     * definition.
-     */
     vars?: Record<string, any>;
-    /**
-     * A component can define namespaces on it, with the <ComponentName xmlns:KEY="VALUE" /> syntax
-     * these are used later to resolve the `type` of the componentDef.
-     * <KEY:Button/> will have type `VALUE.Button` (joined with a "." (dot) )
-     */
     namespaces?: Record<string, string>;
-    /**
-     * Arbitrary debug information that can be attached to a component definition.
-     * Current usage:
-     * - `debug: { source: { start: number, end: number } }` Ther start and end positions of of the source
-     *   belonging to the particular component definition.
-     */
     debug?: Record<string, any>;
     codeBehind?: string;
 }
@@ -777,10 +421,6 @@ declare interface ConstStatement extends ScripNodeBase {
     decls: VarDeclaration[];
 }
 
-/**
- * We store the state application state in a hierarchical structure of containers. This type represents
- * the state within a single container stored as key and value pairs.
- */
 declare type ContainerState = Record<string | symbol, any>;
 
 declare type CONTINUE_STATEMENT = typeof T_CONTINUE_STATEMENT;
@@ -855,23 +495,8 @@ declare interface DoWhileStatement extends ScripNodeBase {
     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;
 }
 
@@ -983,36 +608,12 @@ declare interface Extension {
 
 declare type ExtensionRegisteredCallbackFn = (extension: Extension) => void;
 
-/**
- * This type describes a font definition resource.
- */
 declare type FontDef = {
-    /**
-     * Specifies a name that will be used as the font face value for font properties
-     */
     fontFamily: string;
-    /**
-     * A fontStyle value. Accepts two values to specify a range that is supported by a font-face,
-     * for example `fontStyle: oblique 20deg 50deg`
-     */
     fontStyle?: string;
-    /**
-     * A font-weight value. Accepts two values to specify a range that is supported by a font-face,
-     * for example `font-weight: 100 900`
-     */
     fontWeight?: string;
-    /**
-     * This property determines how a font face is displayed based on whether and when it is downloaded
-     * and ready to use.
-     */
     fontDisplay?: string;
-    /**
-     * The mime type of the font file
-     */
     format?: string;
-    /**
-     * Specifies references to font resources.
-     */
     src: string;
 } | string;
 
@@ -1155,29 +756,9 @@ declare type InterceptorOperationDef = {
 
 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;
 };
 
@@ -1230,58 +811,20 @@ declare const Logo: ForwardRefExoticComponent<    {
 style?: CSSProperties;
 } & RefAttributes<HTMLImageElement>>;
 
-/**
- * This type represents the options to use for looking up actions.
- */
 declare type LookupActionOptions = {
-    /**
-     * This property (by default, true) indicates that any error should be signed while
-     * executing an event handler. Set it to `false` to suppress error indication.
-     */
     signError?: boolean;
-    /**
-     * We can use the event's name to get info about a particular event's progress. Note: Multiple
-     * events can run simultaneously.
-     */
     eventName?: string;
-    /**
-     * By default, we cache resolved action functions. This property signs that we don't want to cache
-     * this function. Use true on one-off handlers, like the ones in Actions (e.g., `MutateAction`).
-     */
     ephemeral?: boolean;
-    /**
-     * This property declares the script code to use as a default for a particular event handler.
-     */
     defaultHandler?: string;
     context?: any;
 };
 
-/**
- * This function resolves an action by its name with the specified options and returns the action
- * function if found. Otherwise, return undefined.
- */
 declare type LookupAsyncFn = (action: string | undefined, actionOptions?: LookupActionOptions) => AsyncFunction | undefined;
 
-/**
- * This function resolves an action by its name (within the component node that runs the action)
- * with the specified options and returns the action function if found. Otherwise, return undefined.
- */
-declare type LookupAsyncFnInner = (action: string | undefined, 
-/**
- * The unique identifier of the container that the action is executed in.
- */
-uid: symbol, actionOptions?: LookupActionOptions) => AsyncFunction | undefined;
+declare type LookupAsyncFnInner = (action: string | undefined, 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";
@@ -1338,7 +881,7 @@ declare interface NavHierarchyNode {
     lastLink?: boolean;
 }
 
-declare function NestedApp({ api, app, components, config, activeTheme, activeTone, title, height, allowPlaygroundPopup, withFrame, style, refVersion, }: NestedAppProps): JSX_2.Element;
+declare function NestedApp({ api, app, components, config, activeTheme, activeTone, title, height, allowPlaygroundPopup, popOutUrl, withFrame, style, refVersion, }: NestedAppProps): JSX_2.Element;
 
 declare type NestedAppProps = {
     api?: any;
@@ -1350,6 +893,7 @@ declare type NestedAppProps = {
     title?: string;
     height?: string | number;
     allowPlaygroundPopup?: boolean;
+    popOutUrl?: string;
     withFrame?: boolean;
     style?: CSSProperties;
     splitView?: boolean;
@@ -1422,10 +966,6 @@ declare type ProjectCompilation = {
     themes: Record<string, ThemeDefinition>;
 };
 
-/**
- * This type represents the description of a property value, which can be a string, a number,
- * or an object with a value and a description. This type is used in the metadata of a component.
- */
 declare type PropertyValueDescription = string | number | {
     value: string | number;
     description: string;
@@ -1506,49 +1046,18 @@ declare interface ReactiveVarDeclaration extends ExpressionBase {
     expr: Expression;
 }
 
-/**
- * This type represents a function that registers all API endpoints of a particular component.
- */
 declare type RegisterComponentApiFn = (componentApi: ComponentApi) => void;
 
 declare type RenderChildFn<L extends ComponentDef = ComponentDef> = (children?: ComponentDef | ComponentDef[] | DynamicChildComponentDef | DynamicChildComponentDef[] | string, layoutContext?: LayoutContext<L>, parentRenderContext?: ParentRenderContext, uidInfoRef?: RefObject<Record<string, any>>, ref?: ForwardedRef<any>) => ReactNode | ReactNode[];
 
-/**
- * This interface defines the renderer context for the exposed components of the XMLUI framework.
- */
 declare interface RendererContext<TMd extends ComponentMetadata = ComponentMetadata> extends ComponentRendererContextBase<TMd> {
-    /**
-     * The unique identifier of the component instance
-     */
     uid: symbol;
-    /**
-     * A component invokes this function to change its internal state
-     */
     updateState: UpdateStateFn;
-    /**
-     * When a component wants to access a property value (which may contain a binding expression to
-     * evaluate), it must use this property to get the current value.
-     */
     extractValue: ValueExtractor;
-    /**
-     * This function gets a physical resource URL according to the provided logical URL.
-     */
     extractResourceUrl: (url?: string) => string | undefined;
-    /**
-     * This function gets an async executable function that handles an event.
-     */
     lookupEventHandler: LookupEventHandlerFn<TMd>;
-    /**
-     * A component can register its APIs with this function
-     */
     registerComponentApi: RegisterComponentApiFn;
-    /**
-     * This function obtains an action by its name with the specified options
-     */
     lookupAction: LookupAsyncFn;
-    /**
-     * This function retrieves a sync function the component can use as a callback
-     */
     lookupSyncCallback: LookupSyncFn;
     layoutCss: CSSProperties;
 }
@@ -1573,21 +1082,9 @@ declare interface ScripNodeBase {
     endToken?: ScriptingToken;
 }
 
-/**
- * This interface holds the properties representing a scriptable component definition.
- */
 declare interface Scriptable {
-    /**
-     * This property holds the text defined in all <script> sections attached to a component.
-     */
     script?: string;
-    /**
-     * This property holds the parsed form of scripts stored in code-behind files.
-     */
     scriptCollected?: CollectedDeclarations;
-    /**
-     * This property holds errors coming from parsing the code-behind scripts.
-     */
     scriptError?: any;
 }
 
@@ -1922,98 +1419,95 @@ declare interface SwitchStatement extends ScripNodeBase {
     cases: SwitchCase[];
 }
 
-/**
- * XMLUI executes some code synchronously. This type defines those functions' signature
- */
 declare type SyncFunction = (...args: any) => any;
 
-declare const T_ARRAY_DESTRUCTURE = 202;
+declare const T_ARRAY_DESTRUCTURE: number;
 
-declare const T_ARRAY_LITERAL = 110;
+declare const T_ARRAY_LITERAL: number;
 
-declare const T_ARROW_EXPRESSION = 115;
+declare const T_ARROW_EXPRESSION: number;
 
-declare const T_ARROW_EXPRESSION_STATEMENT = 4;
+declare const T_ARROW_EXPRESSION_STATEMENT: number;
 
-declare const T_ASSIGNMENT_EXPRESSION = 113;
+declare const T_ASSIGNMENT_EXPRESSION: number;
 
-declare const T_BINARY_EXPRESSION = 101;
+declare const T_BINARY_EXPRESSION: number;
 
-declare const T_BLOCK_STATEMENT = 1;
+declare const T_BLOCK_STATEMENT: number;
 
-declare const T_BREAK_STATEMENT = 10;
+declare const T_BREAK_STATEMENT: number;
 
-declare const T_CALCULATED_MEMBER_ACCESS_EXPRESSION = 106;
+declare const T_CALCULATED_MEMBER_ACCESS_EXPRESSION: number;
 
-declare const T_CONDITIONAL_EXPRESSION = 103;
+declare const T_CONDITIONAL_EXPRESSION: number;
 
-declare const T_CONST_STATEMENT = 6;
+declare const T_CONST_STATEMENT: number;
 
-declare const T_CONTINUE_STATEMENT = 11;
+declare const T_CONTINUE_STATEMENT: number;
 
-declare const T_DESTRUCTURE = 201;
+declare const T_DESTRUCTURE: number;
 
-declare const T_DO_WHILE_STATEMENT = 13;
+declare const T_DO_WHILE_STATEMENT: number;
 
-declare const T_EMPTY_STATEMENT = 2;
+declare const T_EMPTY_STATEMENT: number;
 
-declare const T_EXPRESSION_STATEMENT = 3;
+declare const T_EXPRESSION_STATEMENT: number;
 
-declare const T_FOR_IN_STATEMENT = 15;
+declare const T_FOR_IN_STATEMENT: number;
 
-declare const T_FOR_OF_STATEMENT = 16;
+declare const T_FOR_OF_STATEMENT: number;
 
-declare const T_FOR_STATEMENT = 14;
+declare const T_FOR_STATEMENT: number;
 
-declare const T_FUNCTION_DECLARATION = 20;
+declare const T_FUNCTION_DECLARATION: number;
 
-declare const T_FUNCTION_INVOCATION_EXPRESSION = 104;
+declare const T_FUNCTION_INVOCATION_EXPRESSION: number;
 
-declare const T_IDENTIFIER = 107;
+declare const T_IDENTIFIER: number;
 
-declare const T_IF_STATEMENT = 8;
+declare const T_IF_STATEMENT: number;
 
-declare const T_LET_STATEMENT = 5;
+declare const T_LET_STATEMENT: number;
 
-declare const T_LITERAL = 109;
+declare const T_LITERAL: number;
 
-declare const T_MEMBER_ACCESS_EXPRESSION = 105;
+declare const T_MEMBER_ACCESS_EXPRESSION: number;
 
-declare const T_NO_ARG_EXPRESSION = 114;
+declare const T_NO_ARG_EXPRESSION: number;
 
-declare const T_OBJECT_DESTRUCTURE = 203;
+declare const T_OBJECT_DESTRUCTURE: number;
 
-declare const T_OBJECT_LITERAL = 111;
+declare const T_OBJECT_LITERAL: number;
 
-declare const T_POSTFIX_OP_EXPRESSION = 117;
+declare const T_POSTFIX_OP_EXPRESSION: number;
 
-declare const T_PREFIX_OP_EXPRESSION = 116;
+declare const T_PREFIX_OP_EXPRESSION: number;
 
-declare const T_REACTIVE_VAR_DECLARATION = 118;
+declare const T_REACTIVE_VAR_DECLARATION: number;
 
-declare const T_RETURN_STATEMENT = 9;
+declare const T_RETURN_STATEMENT: number;
 
-declare const T_SEQUENCE_EXPRESSION = 102;
+declare const T_SEQUENCE_EXPRESSION: number;
 
-declare const T_SPREAD_EXPRESSION = 112;
+declare const T_SPREAD_EXPRESSION: number;
 
-declare const T_SWITCH_CASE = 204;
+declare const T_SWITCH_CASE: number;
 
-declare const T_SWITCH_STATEMENT = 19;
+declare const T_SWITCH_STATEMENT: number;
 
-declare const T_TEMPLATE_LITERAL_EXPRESSION = 108;
+declare const T_TEMPLATE_LITERAL_EXPRESSION: number;
 
-declare const T_THROW_STATEMENT = 17;
+declare const T_THROW_STATEMENT: number;
 
-declare const T_TRY_STATEMENT = 18;
+declare const T_TRY_STATEMENT: number;
 
-declare const T_UNARY_EXPRESSION = 100;
+declare const T_UNARY_EXPRESSION: number;
 
-declare const T_VAR_DECLARATION = 200;
+declare const T_VAR_DECLARATION: number;
 
-declare const T_VAR_STATEMENT = 7;
+declare const T_VAR_STATEMENT: number;
 
-declare const T_WHILE_STATEMENT = 12;
+declare const T_WHILE_STATEMENT: number;
 
 declare type Tab = {
     label: string;
@@ -2058,28 +1552,10 @@ declare type TextVariant = (typeof TextVariantKeys)[number];
 
 declare const TextVariantKeys: readonly ["abbr", "cite", "code", "codefence", "deleted", "inherit", "inserted", "keyboard", "marked", "sample", "sub", "sup", "var", "strong", "em", "mono", "title", "subtitle", "small", "caption", "placeholder", "paragraph", "subheading", "tableheading", "secondary"];
 
-/**
- * This type represents a theme definition object. Theme files can use this object's JSON-serialized
- * format to define an app theme; an app can have multiple theme files.
- */
 declare interface ThemeDefinition extends ThemeDefinitionDetails {
-    /**
-     * Theme id
-     */
     id: string;
-    /**
-     * Optional theme name
-     */
     name?: string;
-    /**
-     * A theme can extend existing themes. The extension means that the theme variable values defined
-     * in the new theme override the base theme's variable values.
-     */
     extends?: string | Array<string>;
-    /**
-     * This property defines the tone-dependent theme variable values. When a theme variable value is
-     * resolved, the common theme variable values are overridden with their theme-specific values.
-     */
     tones?: Record<string | ThemeTone, ThemeDefinitionDetails>;
 }
 
@@ -2093,64 +1569,18 @@ declare type ThemeIdDescriptor = {
     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-verticalAlignment-Text-sub": "sub";
-     * "--xmlui-backgroundColor": "var(--xmlui-color-surface-50)"
-     */
     themeStyles: Record<string, string>;
-    /**
-     * This hash object stores the theme variable names with their CSS values definition, like
-     * "verticalAlignment-Text-sub": "sub"; "backgroundColor": "var(--xmlui-color-surface-50)".
-     */
     themeVars: Record<string, string>;
-    /**
-     * This function retrieves the physical path of the provided resource. The path can be used
-     * as a URL in HTML tags, like in the `src` attribute of `<img>`.
-     * @param resourceString The recource name to resolve to an URL
-     */
     getResourceUrl: (resourceString?: string) => string | undefined;
-    /**
-     * This function gets the value of the specified theme variable.
-     * @param themeVar Theme variable name to resolve
-     */
     getThemeVar: (themeVar: string) => string | undefined;
 };
 
-/**
- * This type describes one the available theme tones.
- */
-declare type ThemeTone = (typeof ThemeToneKeys)[number];
-
-/**
- * Each theme can have a light or a dark tone.
- */
-declare const ThemeToneKeys: readonly ["light", "dark"];
+declare type ThemeTone = "light" | "dark";
 
 declare type THROW_STATEMENT = typeof T_THROW_STATEMENT;
 
@@ -2312,10 +1742,6 @@ declare interface UnaryExpression extends ExpressionBase {
 
 declare type UnaryOpSymbols = "+" | "-" | "~" | "!" | "typeof" | "delete";
 
-/**
- * This function updates the state of a component.
- * @param componentState The new state of the component
- */
 declare type UpdateStateFn = (componentState: any, options?: any) => void;
 
 declare function useAppLayoutContext(): IAppLayoutContext;
@@ -2353,63 +1779,16 @@ declare type ValidationStatus = (typeof validationStatusValues)[number];
 
 declare const validationStatusValues: readonly ["none", "error", "warning", "valid"];
 
-/**
- * This type represent the function that extracts the value from a component property
- */
 declare type ValueExtractor = {
-    /**
-     * Get a value (any) from a component property
-     * @param expression Value expression
-     * @param strict Strict matching?
-     */
     (expression?: any, strict?: boolean): any;
-    /**
-     * Get a string value from an expression
-     * @param expression Value expression
-     */
     asString(expression?: any): string;
-    /**
-     * Get an optional string value from an expression
-     * @param expression Value expression
-     * @param defValue Default value, if the parameter value is undefined
-     */
     asOptionalString<T extends string>(expression?: any, defValue?: string): T | undefined;
-    /**
-     * Get an optional string value from an expression
-     * @param expression Value expression
-     */
     asOptionalStringArray(expression?: any): (string | undefined)[];
-    /**
-     * Get a display string value from an expression
-     * @param expression Value expression
-     */
     asDisplayText(expression?: any): string;
-    /**
-     * Get a number value from an expression
-     * @param expression Value expression
-     */
     asNumber(expression?: any): number;
-    /**
-     * Get an optional number value from an expression
-     * @param expression Value expression
-     * @param defValue Default value, if the parameter value is undefined
-     */
     asOptionalNumber(expression?: any, defValue?: number): number | undefined;
-    /**
-     * Get a boolean value (JavaScript semantics) from an expression
-     * @param expression Value expression
-     */
     asBoolean(expression?: any): boolean;
-    /**
-     * Get an optional Boolean value from an expression
-     * @param expression Value expression
-     * @param defValue Default value, if the parameter value is undefined
-     */
     asOptionalBoolean(expression?: any, defValue?: boolean): boolean | undefined;
-    /**
-     * Get a CSS size value from an expression
-     * @param expression Value expression
-     */
     asSize(expression?: any): string;
 };