xmlui 0.7.29 → 0.7.31

package/dist/xmlui-parser.d.ts

@@ -0,0 +1,1488 @@
+declare type ApiInterceptorDefinition = {
+    type?: string;
+    config?: Record<string, any>;
+    schemaDescriptor?: SchemaDescriptor;
+    apiUrl?: string;
+    initialData?: Record<string, any[]> | (() => Promise<Record<string, any[]>>);
+    helpers?: Record<string, any>;
+    initialize?: string;
+    operations?: Record<string, InterceptorOperationDef>;
+    auth?: AuthDefinition;
+};
+
+declare interface ArrayDestructure extends DestructureBase {
+    type: "ADestr";
+}
+
+declare interface ArrayLiteral extends ExpressionBase {
+    type: "ALitE";
+    items: Expression[];
+    loose?: boolean;
+}
+
+declare interface ArrowExpression extends ExpressionBase {
+    type: "ArrowE";
+    name?: string;
+    args: Expression[];
+    statement: Statement;
+    closureContext?: BlockScope[];
+}
+
+declare interface ArrowExpressionStatement extends StatementBase {
+    type: "ArrowS";
+    expression: ArrowExpression;
+}
+
+declare interface AssignmentExpression extends ExpressionBase {
+    type: "AsgnE";
+    leftValue: Expression;
+    operator: AssignmentSymbols;
+    operand: Expression;
+}
+
+declare type AssignmentSymbols = "=" | "+=" | "-=" | "**=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|=" | "&&=" | "||=" | "??=";
+
+declare type AuthDefinition = {
+    defaultLoggedInUser?: any;
+};
+
+declare interface BaseNode {
+    /**
+     * Node type discriminator
+     */
+    type: Node_3["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";
+}
+
+declare interface CalculatedMemberAccessExpression extends ExpressionBase {
+    type: "CMembE";
+    object: Expression;
+    member: Expression;
+}
+
+export declare const enum CharacterCodes {
+    EOF = -1,
+    nullCharacter = 0,
+    maxAsciiCharacter = 127,
+    lineFeed = 10,
+    carriageReturn = 13,
+    lineSeparator = 8232,
+    paragraphSeparator = 8233,
+    nextLine = 133,
+    space = 32,
+    nonBreakingSpace = 160,
+    enQuad = 8192,
+    emQuad = 8193,
+    enSpace = 8194,
+    emSpace = 8195,
+    threePerEmSpace = 8196,
+    fourPerEmSpace = 8197,
+    sixPerEmSpace = 8198,
+    figureSpace = 8199,
+    punctuationSpace = 8200,
+    thinSpace = 8201,
+    hairSpace = 8202,
+    zeroWidthSpace = 8203,
+    narrowNoBreakSpace = 8239,
+    ideographicSpace = 12288,
+    mathematicalSpace = 8287,
+    ogham = 5760,
+    replacementCharacter = 65533,
+    _ = 95,
+    $ = 36,
+    _0 = 48,
+    _1 = 49,
+    _2 = 50,
+    _3 = 51,
+    _4 = 52,
+    _5 = 53,
+    _6 = 54,
+    _7 = 55,
+    _8 = 56,
+    _9 = 57,
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    ampersand = 38,
+    asterisk = 42,
+    at = 64,
+    backslash = 92,
+    backtick = 96,
+    bar = 124,
+    caret = 94,
+    closeBrace = 125,
+    closeBracket = 93,
+    closeParen = 41,
+    colon = 58,
+    comma = 44,
+    dot = 46,
+    doubleQuote = 34,
+    equals = 61,
+    exclamation = 33,
+    greaterThan = 62,
+    hash = 35,
+    lessThan = 60,
+    minus = 45,
+    openBrace = 123,
+    openBracket = 91,
+    openParen = 40,
+    percent = 37,
+    plus = 43,
+    question = 63,
+    semicolon = 59,
+    singleQuote = 39,
+    slash = 47,
+    tilde = 126,
+    backspace = 8,
+    formFeed = 12,
+    byteOrderMark = 65279,
+    tab = 9,
+    verticalTab = 11
+}
+
+export declare const codeBehindFileExtension = "xmlui.xs";
+
+declare type CodeDeclaration = {
+    source?: string;
+    tree: Expression;
+    [x: string]: unknown;
+};
+
+declare type CollectedDeclarations = {
+    vars: Record<string, CodeDeclaration>;
+    functions: Record<string, CodeDeclaration>;
+    moduleErrors?: ModuleErrors;
+};
+
+/**
+ * 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>;
+}
+
+export declare const componentFileExtension = "xmlui";
+
+/**
+ * Sometimes, components and compound components can both be used
+ */
+declare type ComponentLike = ComponentDef | CompoundComponentDef;
+
+export declare type ComponentLints = {
+    lints: {
+        message: string;
+        kind: LintDiagKind;
+    }[];
+    componentName: string;
+};
+
+/**
+ * Components have metadata that the rendering engine uses to render the
+ * component. This type defines the structure of such metadata.
+ *
+ * The type has generic parameters to ensure that type-checking works with
+ * the metadata defined here in concert with the renderer object using the
+ * same metadata type.
+ */
+declare type ComponentMetadata<TProps extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TEvents extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TContextValues extends Record<string, ComponentPropertyMetadata> = Record<string, any>, TApis extends Record<string, ComponentPropertyMetadata> = Record<string, any>> = {
+    status?: "stable" | "experimental" | "deprecated" | "in progress";
+    description?: string;
+    shortDescription?: string;
+    props?: TProps;
+    events?: TEvents;
+    contextVars?: TContextValues;
+    apis?: TApis;
+    nonVisual?: boolean;
+    opaque?: boolean;
+    themeVars?: Array<string>;
+    defaultThemeVars?: DefaultThemeVars;
+    toneSpecificThemeVars?: Record<string, Record<string, string>>;
+    allowArbitraryProps?: boolean;
+    specializedFrom?: string;
+    docFolder?: string;
+    isHtmlTag?: boolean;
+};
+
+/**
+ * Components have properties, events, context values, and exposed API
+ * endpoints, each holding metadata the rendering engine uses at run time.
+ * This type defines the structure of such metadata.
+ */
+declare type ComponentPropertyMetadata = {
+    /**
+     * This field defines the description explaining the property. You can use
+     * markdown, as the UI may display this value.
+     */
+    readonly description: string;
+    /**
+     * This field defines the type of the property. The rendering engine uses this
+     * information to validate the property value.
+     */
+    readonly valueType?: PropertyValueType;
+    /**
+     * This field defines the available values of the property. The rendering engine
+     * uses this information to validate the property value.
+     */
+    readonly availableValues?: readonly PropertyValueDescription[];
+    /**
+     * This field defines the default value of the property. The rendering engine uses
+     * this information to set the default value of the property.
+     */
+    defaultValue?: any;
+    /**
+     * This field defines a validation function that the rendering engine uses to validate
+     * the property value. The function returns one or more hinst if the property value is
+     * invalid.
+     */
+    isValid?: IsValidFunction<any>;
+    /**
+     * Indicates that a particular property is internal and should not be exposed in the
+     * documentation
+     */
+    isInternal?: boolean;
+    /**
+     * Indicates that a particular property is required for the component to essentially function.
+     */
+    isRequired?: boolean;
+};
+
+export declare const COMPOUND_COMP_ID = "Component";
+
+/**
+ * XMLUI allows the creation of reusable components assembled from other XMLUI components (with markup).
+ * This type represents such components. The name `CompoundComponent` refers to the assembled nature
+ * of reusable components.
+ */
+declare interface CompoundComponentDef extends Scriptable {
+    /**
+     * Each compound component must have a unique name. The markup uses this name to refer to the
+     * particular compound component.
+     */
+    name: string;
+    /**
+     * Each compound component must have a single root component defining the component contents.
+     */
+    component: ComponentDef;
+    /**
+     * Compound components may provide an API that other components can use to interact with them. This
+     * property holds the API methods associated with this compound component definition.
+     */
+    api?: Record<string, any>;
+    /**
+     * This property holds the variables (name and value pairs) associated with this compound component
+     * definition.
+     */
+    vars?: Record<string, any>;
+    /**
+     * A component can define namespaces on it, with the <ComponentName xmlns:KEY="VALUE" /> syntax
+     * these are used later to resolve the `type` of the componentDef.
+     * <KEY:Button/> will have type `VALUE.Button` (joined with a "." (dot) )
+     */
+    namespaces?: Record<string, string>;
+    /**
+     * Arbitrary debug information that can be attached to a component definition.
+     * Current usage:
+     * - `debug: { source: { start: number, end: number } }` Ther start and end positions of of the source
+     *   belonging to the particular component definition.
+     */
+    debug?: Record<string, any>;
+}
+
+declare interface ConditionalExpression extends ExpressionBase {
+    type: "CondE";
+    condition: Expression;
+    consequent: Expression;
+    alternate: Expression;
+}
+
+declare interface ConstStatement extends StatementBase {
+    type: "ConstS";
+    declarations: VarDeclaration[];
+    isExported?: boolean;
+}
+
+declare interface ContinueStatement extends StatementBase {
+    type: "ContS";
+}
+
+export declare const CORE_NAMESPACE_VALUE = "#xmlui-core-ns";
+
+export declare function createScanner(skipTrivia: boolean, textInitial?: string, onError?: ScannerErrorCallback, start?: number, length?: number): Scanner;
+
+export declare function createXmlUiParser(source: string): {
+    parse: () => ParseResult;
+    getText: GetText;
+};
+
+declare type DefaultThemeVars = Record<string | ThemeTone, string | Record<string, string>>;
+
+declare interface Destructure extends DestructureBase {
+    type: "Destr";
+    arrayDestruct?: ArrayDestructure[];
+    objectDestruct?: ObjectDestructure[];
+}
+
+declare interface DestructureBase extends ExpressionBase {
+    id?: string;
+    arrayDestruct?: ArrayDestructure[];
+    objectDestruct?: ObjectDestructure[];
+}
+
+export declare const Diag_Attr_Identifier_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expAttrIdent;
+    readonly message: "An attribute identifier expected.";
+};
+
+export declare const Diag_Attr_Value_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expAttrValue;
+    readonly message: "An attribute value expected.";
+};
+
+export declare const Diag_CloseNodeStart_Token_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expCloseStart;
+    readonly message: "A '</' token expected.";
+};
+
+export declare const Diag_End_Or_Close_Token_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expEndOrClose;
+    readonly message: "A '>' or '/>' token expected.";
+};
+
+export declare const Diag_End_Token_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expEnd;
+    readonly message: "A '>' token expected.";
+};
+
+export declare const Diag_Eq_Token_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expEq;
+    readonly message: "An '=' token expected.";
+};
+
+export declare const Diag_Invalid_Character: {
+    readonly code: ErrCodes.invalidChar;
+    readonly category: DiagnosticCategory.Error;
+    readonly message: "Invalid character.";
+};
+
+export declare const Diag_OpenNodeStart_Token_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expTagOpen;
+    readonly message: "A '<' token expected.";
+};
+
+export declare const Diag_Tag_Identifier_Expected: {
+    readonly category: DiagnosticCategory.Error;
+    readonly code: ErrCodes.expTagIdent;
+    readonly message: "A tag identifier expected.";
+};
+
+export declare const Diag_Unterminated_CData: {
+    readonly code: ErrCodes.untermCData;
+    readonly category: DiagnosticCategory.Error;
+    readonly message: "Unterminated CDATA section";
+};
+
+export declare const Diag_Unterminated_Comment: {
+    readonly code: ErrCodes.untermComment;
+    readonly category: DiagnosticCategory.Error;
+    readonly message: "Unterminated comment";
+};
+
+export declare const Diag_Unterminated_Script: {
+    readonly code: ErrCodes.untermScript;
+    readonly category: DiagnosticCategory.Error;
+    readonly message: "Unterminated script section";
+};
+
+export declare const Diag_Unterminated_String_Literal: {
+    readonly code: ErrCodes.untermStr;
+    readonly category: DiagnosticCategory.Error;
+    readonly message: "Unterminated string literal.";
+};
+
+export declare enum DiagnosticCategory {
+    Warning = 0,
+    Error = 1,
+    Suggestion = 2,
+    Message = 3
+}
+
+export declare function diagnosticCategoryName(d: {
+    category: DiagnosticCategory;
+}, lowerCase?: boolean): string;
+
+export declare type DiagnosticMessage = DiagnosticMessageFromScanner | DiagnosticMessageFromParser;
+
+declare type DiagnosticMessageFromParser = typeof Diag_End_Token_Expected | typeof Diag_CloseNodeStart_Token_Expected | typeof Diag_Tag_Identifier_Expected | typeof Diag_Attr_Value_Expected | typeof Diag_Eq_Token_Expected | typeof Diag_OpenNodeStart_Token_Expected | typeof Diag_End_Or_Close_Token_Expected | typeof Diag_Attr_Identifier_Expected;
+
+export declare type DiagnosticMessageFromScanner = typeof Diag_Invalid_Character | typeof Diag_Unterminated_String_Literal | typeof Diag_Unterminated_Comment | typeof Diag_Unterminated_CData | typeof Diag_Unterminated_Script;
+
+declare interface DoWhileStatement extends StatementBase {
+    type: "DoWS";
+    condition: Expression;
+    body: Statement;
+}
+
+declare interface EmptyStatement extends StatementBase {
+    type: "EmptyS";
+}
+
+export declare enum ErrCodes {
+    onlyOneElem = "U002",
+    expTagOpen = "U003",
+    expTagIdent = "U004",
+    expCloseStart = "U005",
+    expEndOrClose = "U006",
+    tagNameMismatch = "U007",
+    expEnd = "U008",
+    expAttrIdent = "U009",
+    expEq = "U010",
+    expAttrValue = "U011",
+    duplAttr = "U012",
+    uppercaseAttr = "U013",
+    invalidChar = "W001",
+    untermStr = "W002",
+    untermComment = "W007",
+    untermCData = "W008",
+    untermScript = "W009"
+}
+
+declare interface Error_2 {
+    readonly category: DiagnosticCategory;
+    readonly code: ErrCodes;
+    readonly message: string;
+    readonly pos: number;
+    readonly end: number;
+}
+export { Error_2 as Error }
+
+export declare type ErrorCodes = "U001" | "U002" | "U003" | "U004" | "U005" | "U006" | "U007" | "U008" | "U009" | "U010" | "U011" | "U012" | "U013" | "U014" | "U015" | "T001" | "T002" | "T003" | "T004" | "T005" | "T006" | "T007" | "T008" | "T009" | "T010" | "T011" | "T012" | "T013" | "T014" | "T015" | "T016" | "T017" | "T018" | "T019" | "T020" | "T021" | "T022" | "T023" | "T024" | "T025" | "T026" | "T027" | "T028" | "T029";
+
+export declare const errorMessages: ErrorText;
+
+declare type ErrorText = Record<ErrorCodes, string>;
+
+declare type Expression = UnaryExpression | BinaryExpression | SequenceExpression | ConditionalExpression | FunctionInvocationExpression | MemberAccessExpression | CalculatedMemberAccessExpression | Identifier | Literal | ArrayLiteral | ObjectLiteral | SpreadExpression | AssignmentExpression | NoArgExpression | ArrowExpression | PrefixOpExpression | PostfixOpExpression | ReactiveVarDeclaration | VarDeclaration | Destructure | ObjectDestructure | ArrayDestructure | TemplateLiteralExpression;
+
+declare interface ExpressionBase extends BaseNode {
+    value?: any;
+    parenthesized?: number;
+    valueScope?: any;
+    valueIndex?: string | number;
+}
+
+declare interface ExpressionStatement extends StatementBase {
+    type: "ExprS";
+    expression: Expression;
+}
+
+export declare function findTokenAtPos(node: Node_2, position: number): FindTokenSuccess | undefined;
+
+/** If the position is in-between two tokens, the chain to the token just before the cursor is provided as well, but the shared parents are inside field chainAtPos */
+declare type FindTokenSuccess = {
+    chainAtPos: Node_2[];
+    /** If the position is in-between two tokens, the chain to the token just before the position is provided.
+     stores syntax elements from the fork point to the token */
+    chainBeforePos?: Node_2[];
+    /** Only undefined when chainBeforePos is.
+     * chainBeforePos starts with the first node or token after the fork point.
+     * This field specifies the index of the 0th element of the chainBeforePos if it's parents were part of the array as well. */
+    sharedParents?: number;
+};
+
+/**
+ * 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 interface GeneralDiagnosticMessage {
+    code: ErrCodes;
+    category: DiagnosticCategory;
+    message: string;
+}
+
+export declare function getLintSeverity(lintSeverityOption: string | undefined): LintSeverity;
+
+export declare function getSyntaxKindStrRepr(kind: SyntaxKind): string;
+
+export declare type GetText = (n: Node_2, ignoreTrivia?: boolean) => string;
+
+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;
+};
+
+export declare function isIdentifierStart(ch: number): boolean;
+
+export declare function isInnerNode(token: SyntaxKind): boolean;
+
+export declare function isTrivia(token: SyntaxKind): boolean;
+
+declare type IsValidFunction<T> = (propKey: string, propValue: T) => string | string[] | undefined | null;
+
+declare interface LetStatement extends StatementBase {
+    type: "LetS";
+    declarations: VarDeclaration[];
+}
+
+export declare function lint({ component, metadataByComponent, }: {
+    component: CompoundComponentDef | ComponentDef;
+    metadataByComponent: Record<string, ComponentMetadata>;
+}): LintDiagnostic[];
+
+export declare function lintApp({ appDef, metadataByComponent, }: {
+    appDef: StandaloneAppDescription;
+    metadataByComponent: Record<string, ComponentMetadata>;
+}): ComponentLints[];
+
+export declare enum LintDiagKind {
+    UnrecognisedProp = 0
+}
+
+declare type LintDiagnostic = {
+    message: string;
+    kind: LintDiagKind;
+};
+
+export declare function lintErrorsComponent(lints: ComponentLints[]): ComponentDef<ComponentMetadata<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
+
+export declare enum LintSeverity {
+    Skip = 0,
+    Warning = 1,
+    Error = 2
+}
+
+declare interface Literal extends ExpressionBase {
+    type: "LitE";
+    value: any;
+}
+
+declare interface MemberAccessExpression extends ExpressionBase {
+    type: "MembE";
+    object: Expression;
+    member: string;
+    isOptional?: boolean;
+}
+
+/**
+ * Represents a module error
+ */
+declare type ModuleErrors = Record<string, ScriptParserErrorMessage[]>;
+
+export declare const moduleFileExtension = "xs";
+
+declare type ModuleResolver = (sourceModule: string, moduleName: string) => string | null;
+
+declare interface NoArgExpression extends ExpressionBase {
+    type: "NoArgE";
+}
+
+declare interface Node_2 extends ReadonlyTextRange {
+    readonly kind: SyntaxKind;
+    readonly start: number;
+    readonly triviaBefore?: Node_2[];
+    readonly children?: Node_2[];
+}
+export { Node_2 as Node }
+
+declare type Node_3 = Statement | Expression | SwitchCase;
+
+export declare function nodeToComponentDef(node: Node_2, originalGetText: GetText, fileId: string | number, moduleResolver?: ModuleResolver): ComponentDef | CompoundComponentDef | null;
+
+declare interface ObjectDestructure extends DestructureBase {
+    type: "ODestr";
+    id: string;
+    alias?: string;
+}
+
+declare interface ObjectLiteral extends ExpressionBase {
+    type: "OLitE";
+    props: (SpreadExpression | [Expression, Expression])[];
+}
+
+export declare const onPrefixRegex: RegExp;
+
+export declare class ParserError extends Error {
+    code?: string;
+    constructor(message: string, code?: string);
+}
+
+export declare interface ParserErrorMessage {
+    code: ErrorCodes;
+    text: string;
+    position: number;
+    line: number;
+    column: number;
+}
+
+export declare type ParseResult = {
+    node: Node_2;
+    errors: Error_2[];
+};
+
+export declare function parseXmlUiMarkup(text: string): ParseResult;
+
+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 = "++" | "--";
+
+export declare function printComponentLints(lintDiags: ComponentLints): void;
+
+/**
+ * This type represents the description of a property value, which can be a string, a number,
+ * or an object with a value and a description. This type is used in the metadata of a component.
+ */
+declare type PropertyValueDescription = string | number | {
+    value: string | number;
+    description: string;
+};
+
+declare type PropertyValueType = "boolean" | "string" | "number" | "any" | "ComponentDef";
+
+declare interface ReactiveVarDeclaration extends ExpressionBase {
+    type: "RVarD";
+    id: string;
+    expression: Expression;
+}
+
+declare interface ReadonlyTextRange {
+    readonly pos: number;
+    readonly end: number;
+}
+
+declare interface ReturnStatement extends StatementBase {
+    type: "RetS";
+    expression?: Expression;
+}
+
+export declare interface Scanner {
+    getStartPos(): number;
+    getToken(): SyntaxKind;
+    getTokenStart(): number;
+    getTokenEnd(): number;
+    getTokenText(): string;
+    getTokenValue(): string;
+    isIdentifier(): boolean;
+    peekChar(ahead?: number): number | null;
+    scanChar(): number | null;
+    scan(): SyntaxKind;
+    scanTrivia(): SyntaxKind | null;
+    scanText(): SyntaxKind;
+    getText(): string;
+    setText(text: string | undefined, start?: number, length?: number): void;
+    setOnError(onError: ScannerErrorCallback | undefined): void;
+    resetTokenState(pos: number): void;
+    back(): void;
+}
+
+export declare type ScannerErrorCallback = (message: DiagnosticMessageFromScanner, length: number, arg0?: any) => void;
+
+declare type SchemaDescriptor = {
+    tables: Array<TableDescriptor>;
+    relationships?: any;
+    dtos?: any;
+};
+
+/**
+ * This interface holds the properties representing a scriptable component definition.
+ */
+declare interface Scriptable {
+    /**
+     * This property holds the text defined in all <script> sections attached to a component.
+     */
+    script?: string;
+    /**
+     * This property holds the parsed form of scripts stored in code-behind files.
+     */
+    scriptCollected?: CollectedDeclarations;
+    /**
+     * This property holds errors coming from parsing the code-behind scripts.
+     */
+    scriptError?: any;
+}
+
+/**
+ * Represents a parsed and resolved module
+ */
+declare type ScriptModule = {
+    type: "ScriptModule";
+    name: string;
+    parent?: ScriptModule | null;
+    exports: Map<string, any>;
+    imports: Record<string, Record<string, any>>;
+    importedModules: ScriptModule[];
+    functions: Record<string, FunctionDeclaration>;
+    statements: Statement[];
+    executed: boolean;
+};
+
+declare interface ScriptParserErrorMessage {
+    code: ScriptParsingErrorCodes;
+    text: string;
+    position?: number;
+    line?: number;
+    column?: number;
+}
+
+declare type ScriptParsingErrorCodes = "W001" | "W002" | "W003" | "W004" | "W005" | "W006" | "W007" | "W008" | "W009" | "W010" | "W011" | "W012" | "W013" | "W014" | "W015" | "W016" | "W017" | "W018" | "W019" | "W020" | "W021" | "W022" | "W023" | "W024" | "W025" | "W026" | "W027" | "W028" | "W029" | "W030" | "W031";
+
+declare interface SequenceExpression extends ExpressionBase {
+    type: "SeqE";
+    expressions: Expression[];
+    loose?: boolean;
+}
+
+declare interface SpreadExpression extends ExpressionBase {
+    type: "SpreadE";
+    operand: Expression;
+}
+
+declare type StandaloneAppDescription = {
+    name?: string;
+    version?: string;
+    entryPoint?: ComponentLike;
+    components?: CompoundComponentDef[];
+    themes?: ThemeDefinition[];
+    defaultTheme?: string;
+    defaultTone?: string;
+    resources?: Record<string, string>;
+    resourceMap?: Record<string, string>;
+    appGlobals?: Record<string, any>;
+    apiInterceptor?: ApiInterceptorDefinition;
+    sources?: Record<string, string>;
+};
+
+declare type 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[];
+}
+
+/** tokens and nodes combined. Order is significant since the functions below use the numeric values of this enum to check for a range of possible values*/
+export declare const enum SyntaxKind {
+    Unknown = 0,
+    EndOfFileToken = 1,
+    CommentTrivia = 2,
+    NewLineTrivia = 3,
+    WhitespaceTrivia = 4,
+    Identifier = 5,
+    OpenNodeStart = 6,
+    CloseNodeStart = 7,
+    NodeEnd = 8,
+    NodeClose = 9,
+    Colon = 10,
+    Equal = 11,
+    StringLiteral = 12,
+    CData = 13,
+    Script = 14,
+    TextNode = 15,
+    AmpersandEntity = 16,
+    LessThanEntity = 17,
+    GreaterThanEntity = 18,
+    SingleQuoteEntity = 19,
+    DoubleQuoteEntity = 20,
+    ElementNode = 21,
+    AttributeNode = 22,
+    AttributeKeyNode = 23,
+    ContentListNode = 24,
+    AttributeListNode = 25,
+    TagNameNode = 26,
+    ErrorNode = 27
+}
+
+declare type TableDescriptor = {
+    name: string;
+    fields?: Record<string, any>;
+    pk: Array<string>;
+    indexes?: Array<string>;
+};
+
+/** Disregards error nodes amongst the children of the 2 compared name node. (Those reported an error earlyer anyways)*/
+export declare function tagNameNodesWithoutErrorsMatch(name1: Node_2, name2: Node_2, getText: GetText): boolean;
+
+declare interface TemplateLiteralExpression extends ExpressionBase {
+    type: "TempLitE";
+    segments: (Literal | Expression)[];
+}
+
+/**
+ * This type represents a theme definition object. Theme files can use this object's JSON-serialized
+ * format to define an app theme; an app can have multiple theme files.
+ */
+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_2, ThemeDefinitionDetails>;
+}
+
+declare interface ThemeDefinitionDetails {
+    themeVars?: Record<string, string>;
+    resources?: Record<string, string | FontDef>;
+}
+
+/**
+ * This type describes one the available theme tones.
+ */
+declare type ThemeTone = (typeof ThemeToneKeys)[number];
+
+/**
+ * This type describes one the available theme tones.
+ */
+declare type ThemeTone_2 = (typeof ThemeToneKeys_2)[number];
+
+/**
+ * Each theme can have a light or a dark tone.
+ */
+declare const ThemeToneKeys: readonly ["light", "dark"];
+
+/**
+ * Each theme can have a light or a dark tone.
+ */
+declare const ThemeToneKeys_2: readonly ["light", "dark"];
+
+declare interface ThrowStatement extends StatementBase {
+    type: "ThrowS";
+    expression: Expression;
+}
+
+export declare function toDbgString(node: Node_2, getText: (node: Node_2) => string, indentationLvl?: number): string;
+
+declare type Token = {
+    readonly text: string;
+    readonly type: TokenType;
+    readonly location: TokenLocation;
+};
+
+declare interface TokenLocation {
+    readonly startPosition: number;
+    readonly endPosition: number;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly startColumn: number;
+    readonly endColumn: number;
+}
+
+declare const enum TokenType {
+    Eof = -1,
+    Ws = -2,
+    BlockComment = -3,
+    EolComment = -4,
+    Unknown = 0,
+    LParent = 1,
+    RParent = 2,
+    Identifier = 3,
+    Exponent = 4,
+    Divide = 5,
+    Multiply = 6,
+    Remainder = 7,
+    Plus = 8,
+    Minus = 9,
+    BitwiseXor = 10,
+    BitwiseOr = 11,
+    LogicalOr = 12,
+    BitwiseAnd = 13,
+    LogicalAnd = 14,
+    IncOp = 15,
+    DecOp = 16,
+    Assignment = 17,
+    AddAssignment = 18,
+    SubtractAssignment = 19,
+    ExponentAssignment = 20,
+    MultiplyAssignment = 21,
+    DivideAssignment = 22,
+    RemainderAssignment = 23,
+    ShiftLeftAssignment = 24,
+    ShiftRightAssignment = 25,
+    SignedShiftRightAssignment = 26,
+    BitwiseAndAssignment = 27,
+    BitwiseXorAssignment = 28,
+    BitwiseOrAssignment = 29,
+    LogicalAndAssignment = 30,
+    LogicalOrAssignment = 31,
+    NullCoalesceAssignment = 32,
+    Semicolon = 33,
+    Comma = 34,
+    Colon = 35,
+    LSquare = 36,
+    RSquare = 37,
+    QuestionMark = 38,
+    NullCoalesce = 39,
+    OptionalChaining = 40,
+    BinaryNot = 41,
+    LBrace = 42,
+    RBrace = 43,
+    Equal = 44,
+    StrictEqual = 45,
+    LogicalNot = 46,
+    NotEqual = 47,
+    StrictNotEqual = 48,
+    LessThan = 49,
+    LessThanOrEqual = 50,
+    ShiftLeft = 51,
+    GreaterThan = 52,
+    GreaterThanOrEqual = 53,
+    ShiftRight = 54,
+    SignedShiftRight = 55,
+    Dot = 56,
+    Spread = 57,
+    Global = 58,
+    Backtick = 59,
+    DollarLBrace = 60,
+    Arrow = 61,
+    DecimalLiteral = 62,
+    HexadecimalLiteral = 63,
+    BinaryLiteral = 64,
+    RealLiteral = 65,
+    StringLiteral = 66,
+    Infinity = 67,
+    NaN = 68,
+    True = 69,
+    False = 70,
+    Typeof = 71,
+    Null = 72,
+    Undefined = 73,
+    In = 74,
+    Let = 75,
+    Const = 76,
+    Var = 77,
+    If = 78,
+    Else = 79,
+    Return = 80,
+    Break = 81,
+    Continue = 82,
+    Do = 83,
+    While = 84,
+    For = 85,
+    Of = 86,
+    Try = 87,
+    Catch = 88,
+    Finally = 89,
+    Throw = 90,
+    Switch = 91,
+    Case = 92,
+    Default = 93,
+    Delete = 94,
+    Function = 95,
+    Export = 96,
+    Import = 97,
+    As = 98,
+    From = 99
+}
+
+declare interface TryStatement extends StatementBase {
+    type: "TryS";
+    tryBlock: BlockStatement;
+    catchBlock?: BlockStatement;
+    catchVariable?: string;
+    finallyBlock?: BlockStatement;
+}
+
+export declare const UCRegex: RegExp;
+
+declare interface UnaryExpression extends ExpressionBase {
+    type: "UnaryE";
+    operator: UnaryOpSymbols;
+    operand: Expression;
+}
+
+declare type UnaryOpSymbols = "+" | "-" | "~" | "!" | "typeof" | "delete";
+
+declare interface VarDeclaration extends ExpressionBase {
+    type: "VarD";
+    id?: string;
+    arrayDestruct?: ArrayDestructure[];
+    objectDestruct?: ObjectDestructure[];
+    expression?: Expression;
+}
+
+declare interface VarStatement extends StatementBase {
+    type: "VarS";
+    declarations: ReactiveVarDeclaration[];
+}
+
+declare interface WhileStatement extends StatementBase {
+    type: "WhileS";
+    condition: Expression;
+    body: Statement;
+}
+
+export declare interface XmlUiAttribute extends XmlUiNodeBase {
+    type: "XmlUiAttribute";
+    name: string;
+    namespace?: string;
+    value?: string;
+    preserveQuotes?: boolean;
+    preserveSpaces?: boolean;
+}
+
+export declare interface XmlUiComment extends XmlUiNodeBase {
+    type: "XmlUiComment";
+    text?: string;
+}
+
+export declare interface XmlUiElement extends XmlUiNodeBase {
+    type: "XmlUiElement";
+    name: string;
+    namespace?: string;
+    attributes?: XmlUiAttribute[];
+    text?: string;
+    preserveSpaces?: boolean;
+    childNodes?: XmlUiNode[];
+}
+
+export declare type XmlUiFragment = XmlUiNode | XmlUiNode[];
+
+/**
+ * Helper class for UEML serialization and parsing
+ */
+export declare class XmlUiHelper {
+    /**
+     * Serialize the specified XML fragment into a string
+     * @param xml XML fragment to serialize
+     * @param options Formatting options to use
+     */
+    serialize(xml: XmlUiFragment, options?: XmluiSerializationOptions): string;
+    /**
+     * Transform the specified component definition into an UEML node
+     * @param def Component definitions
+     * @param options Transformation options
+     */
+    transformComponentDefinition(def: ComponentDef | CompoundComponentDef, options?: XmlUiTransformOptions): XmlUiFragment;
+    /**
+     * Transform the specified object into an UEML nodes
+     * @param def Object definition
+     * @param options Transformation options
+     */
+    transformObject(def: Record<string, any>, options?: XmlUiTransformOptions): XmlUiNode[] | null;
+    /**
+     * Transforms the specified simple component definition into an UEML node
+     * @param def Component definition
+     * @param options Transformation options
+     */
+    private transformSimpleComponentDefinition;
+    /**
+     * Transforms the specified simple component definition into an Xml node
+     * @param def Compound component definition
+     * @param options Transformation options
+     */
+    private transformCompoundComponentDefinition;
+    /**
+     * Transforms a value into an UEML element
+     * @param nodeName Name of the value node
+     * @param name Optional (property) name
+     * @param value Value to transform
+     * @param options Transformation options
+     */
+    private transformValue;
+    /**
+     * Transforms the specified simple component definition into an Xml node
+     * @param name Element name
+     * @param value Value to transform
+     * @param options Transformation options
+     */
+    private transformObjectValue;
+    /**
+     * Add a property to the specified UEML element
+     * @param element XML element
+     * @param name Element name
+     * @param value Element value
+     * @param options Transformation options
+     */
+    private addProperty;
+    private addComponentElement;
+    /**
+     * Adds a list to the specified XML element
+     * @param element XML element
+     * @param name Name of the list (child in `element`)
+     * @param prefix Prefix to use for the list
+     * @param list List with items
+     * @param options Transformation options
+     */
+    private addList;
+    /**
+     * Adds a component list to the specified element
+     * @param element XML element
+     * @param name Name to use for the wrapper element
+     * @param list List with component items
+     * @private
+     */
+    private addComponentList;
+}
+
+export declare type XmlUiNode = XmlUiComment | XmlUiAttribute | XmlUiElement;
+
+export declare interface XmlUiNodeBase {
+    type: XmlUiNode["type"];
+}
+
+export declare type XmluiSerializationOptions = {
+    prettify?: boolean;
+    indents?: number;
+    lineLength?: number;
+    useQuotes?: boolean;
+    useSpaceBeforeClose?: boolean;
+    breakClosingTag?: boolean;
+};
+
+/**
+ * Options to use with markup transformation from memory format to UEML structure
+ */
+export declare type XmlUiTransformOptions = {
+    preserveLineBreaks?: boolean;
+    preserveSpecialChars?: boolean;
+    removeQuotes?: boolean;
+    extractProps?: boolean;
+    preferTextToValue?: boolean;
+};
+
+export { }
+
+
+declare module "@tanstack/table-core" {
+    interface TableMeta<TData extends RowData> {
+        cellRenderer: (...args: any[]) => any;
+    }
+    interface ColumnMeta<TData extends RowData, TValue> {
+        style?: CSSProperties;
+        starSizedWidth?: string;
+        accessorKey?: string;
+        pinTo?: string;
+        cellRenderer?: (row: any, rowIdx: number, colIdx: number, value?: any) => ReactNode;
+    }
+}
+
+
+declare global {
+    interface Window {
+        TEST_ENV: StandaloneAppDescription | undefined;
+    }
+}