asajs 3.0.2 → 3.0.5

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/types/compilers/BindingCompiler.d.ts

@@ -0,0 +1,44 @@
+import { UI } from "../components/UI";
+import { OverrideInterface } from "../types/objects/Modify";
+import { Binding } from "../types/values/Binding";
+export interface BindingFunctionObject {
+    [key: string]: (arg: UI | OverrideInterface, params: Array<string>) => Binding;
+}
+export declare class BindingCompiler {
+    static compile(propertyName: string | string[], arg: UI | OverrideInterface): string;
+    static getCompilePart(propertyName: string | string[]): string;
+    static build(propertyName: string, arg: UI | OverrideInterface): string;
+    static buildNewPropertyBag(token: string, arg: UI | OverrideInterface): any;
+    static checkAndBuild(token: string, arg: UI | OverrideInterface): any;
+    static compileSpecialOperator(tokens: Array<string>, arg: UI | OverrideInterface): string[];
+    static lexer(propertyName: string, arg: UI | OverrideInterface): string[];
+    static splitString(propertyName: string): string[];
+    static stringHandler(token: string, arg: UI | OverrideInterface): string;
+    static getStringTokens(token: string): string[];
+    static functionHandler(token: string, arg: UI | OverrideInterface): string;
+    static readFunctionFromToken(tokens: Array<string>, arg: UI | OverrideInterface): {
+        name: string;
+        params: string[];
+    };
+    static readTokens(strTokens: Array<string>): string[];
+    static getTokens(strTokens: Array<string>): string[];
+    static buildNewBinding(token: string, arg: UI | OverrideInterface): string;
+    static findSourceBindings(token: string, sourceControlsName: string, lastResourceBindings?: any): {
+        reSourceBindings: Record<string, string>;
+        newTokens: string[];
+    };
+    static isCanCompile(token: string | string[]): boolean;
+    static isString(token: string): boolean;
+    static isStringCode(token: string): boolean;
+    static isStringPattern(token: string): boolean;
+    static isNegativeNumber(token: string): boolean;
+    static isScientificNotation(token: string): boolean;
+    static isFunction(token: string): boolean;
+    static isArray(token: string): boolean;
+    static isCodeBlock(token: string): boolean;
+    static maybeFunctionName(token: string): boolean;
+    static isBindingOrVariable(token: string): boolean;
+    static isOperator(token: string): boolean;
+    static isHasBinding(token: string): boolean;
+    static isNumber(value: string): boolean;
+}

package/dist/types/compilers/BindingFunctions.d.ts

@@ -0,0 +1,10 @@
+import { Class } from "../components/Class";
+import { UI } from "../components/UI";
+import { OverrideInterface, ModificationBindingsInterface } from "../types/objects/Modify";
+import { Binding } from "../types/values/Binding";
+import { BindingFunctionObject } from "./BindingCompiler";
+export declare const funcObj: BindingFunctionObject;
+export type BindingFunctionsCallback<T = UI | OverrideInterface | ModificationBindingsInterface> = (element: T, params: Array<string>) => Binding | string;
+export declare class BindingFunctions extends Class {
+    static register<T = UI | OverrideInterface | ModificationBindingsInterface>(name: string, callback: BindingFunctionsCallback<T>, override?: boolean): void;
+}

package/dist/types/compilers/Compiler.d.ts

@@ -0,0 +1,3 @@
+import { ResourcePacks } from "./Installer";
+export declare const installer: ResourcePacks;
+export {};

package/dist/types/compilers/Compress.d.ts

@@ -0,0 +1 @@
+export declare function CompressPack(buildPath: string): void;

package/dist/types/compilers/Config.d.ts

@@ -0,0 +1,95 @@
+import { UUID } from "crypto";
+import { SemverString, Version } from "../types/objects/Manifest";
+/**
+ * Interface representing the structure of a config manifest.
+ * This is used to define the metadata of the resource pack.
+ */
+interface ConfigManifest {
+    name: string;
+    description: string;
+    version: Version | SemverString;
+    baseGameVersion: Version;
+    uuid: UUID;
+}
+interface ConfigCompilerUI {
+    obfuscateName: boolean;
+    obfuscateType: boolean;
+    nameLength: number;
+    namespaceLength: number;
+    namespaceAmount: number;
+}
+interface ConfigCompiler {
+    UI: ConfigCompilerUI;
+    autoCompress: boolean;
+    fileExtension: string;
+    encodeJson: boolean;
+}
+interface ConfigInstaller {
+    autoInstall: boolean;
+    developEvironment: boolean;
+    previewVersion: boolean;
+    customPath: boolean;
+    installPath?: string;
+}
+export interface Config {
+    installer: ConfigInstaller;
+    compiler: ConfigCompiler;
+    manifest: ConfigManifest;
+}
+/**
+ * Reads an object and applies default values where necessary.
+ *
+ * This function allows deeply nested objects to be filled with default values when they are undefined.
+ *
+ * @param {object} [obj] - The object to read and apply the default values to.
+ * @param {object} [defaultObjValue] - The default values to use if any properties in `obj` are undefined.
+ * @returns {object} - The object with default values applied.
+ */
+export declare function readObject(obj?: object, defaultObjValue?: object): object;
+/**
+ * A class to manage and load configuration settings.
+ *
+ * The class allows reading from a configuration file and merging the saved configuration
+ * with default values when necessary.
+ */
+export declare class Configs {
+    /**
+     * The current loaded configuration saved to disk.
+     */
+    save: Config;
+    /**
+     * The statically cached configuration.
+     */
+    static config: Config;
+    /**
+     * Loads the configuration file and parses it into the `save` property.
+     */
+    constructor();
+    /**
+     * Retrieves the current configuration, either from the saved configuration or the default values.
+     *
+     * @returns {Config} - The configuration object.
+     */
+    static getConfig(): Config;
+    /**
+     * Retrieves the default configuration values.
+     *
+     * @returns {Config} - The default configuration object.
+     */
+    static getDefaultConfig(): Config;
+    private static apply;
+    private static arguments;
+    private static bind;
+    private static call;
+    private static caller;
+    private static length;
+    private static name;
+    private static toString;
+}
+/**
+ * Exporting the Configs class to be used globally.
+ *
+ * This allows other modules to access the configuration settings through `config`.
+ */
+export declare const config: typeof Configs;
+export {};

package/dist/types/compilers/Encoder.d.ts

@@ -0,0 +1,11 @@
+import { Class } from "../components/Class";
+export declare class Encoder extends Class {
+    static count: number;
+    static start(): void;
+    static replaceCode(path: string, code: any): void;
+    static encode(code: any): any;
+    static encodeArray(code: any[]): any[];
+    static encodeObject(code: any): object;
+    static encodeString(code: string): string;
+    static readCode(path: string): any;
+}

package/dist/types/compilers/Installer.d.ts

@@ -0,0 +1,14 @@
+import { SemverString, UUID, Version } from "./../types/objects/Manifest";
+import { ResourcePackInterface } from "../types/objects/Installer";
+export declare class ResourcePacks {
+    gamePath: string;
+    gameDataPath: string;
+    installPath: string;
+    globalResoucePacksPath: string;
+    constructor(data: ResourcePackInterface);
+    isPackInstalled(uuid: UUID, version: Version | SemverString): boolean;
+    installPack(uuid: UUID, version: Version | SemverString): void;
+    uninstallPack(uuid: UUID, version: Version | SemverString): void;
+    getInstallPath(): string;
+    packLink(): void;
+}

package/dist/types/compilers/PreCompile.d.ts

@@ -0,0 +1,4 @@
+import fs from "fs";
+export declare function WritePreComment(data: any): string;
+export declare const jsonFilePath: string[];
+export declare function UIWriteJson(file: string, data: any, options?: fs.WriteFileOptions): void;

package/dist/types/compilers/generator/GenerateDir.d.ts

@@ -0,0 +1 @@
+export declare function GenerateDir(installPath: string, path?: string): void;

package/dist/types/compilers/generator/JsonBuilder.d.ts

@@ -0,0 +1,28 @@
+import { AnimationKeyFrame } from "../../components/AnimationKeyFrame";
+import { Class } from "../../components/Class";
+import { Modify } from "../../components/Modify";
+import { UI } from "../../components/UI";
+interface JsonObject {
+    build: {
+        [file: string]: {
+            namespace: string;
+            [element: string]: any;
+        };
+    };
+    modify: {
+        [modifyFilePath: string]: {
+            [path: string]: Modify;
+        };
+    };
+    globalVariables: {
+        [key: `$${string}`]: any;
+    };
+}
+export declare class JsonBuilder extends Class {
+    static save: JsonObject;
+    static registerGlobalVariable(key: string, value: any): void;
+    static registerElement(namespace: string, element: UI | AnimationKeyFrame): void;
+    static getModify(modifyFile: string, modifyElement: string): Modify;
+    static registerModify(modifyFile: string, modifyElement: string, modify: Modify): Modify;
+}
+export {};

package/dist/types/compilers/generator/LangBuilder.d.ts

@@ -0,0 +1,4 @@
+import { Class } from "../../components/Class";
+export declare class LangBuilder extends Class {
+    static build(buildPath: string): number;
+}

package/dist/types/compilers/generator/Log.d.ts

@@ -0,0 +1,9 @@
+import { Class } from "../../components/Class";
+export declare const Logs: Array<{
+    type: "warning" | "error";
+    message: string;
+}>;
+export declare class Log extends Class {
+    static warning(message: string): void;
+    static error(message: string): void;
+}

package/dist/types/compilers/generator/Manifest.d.ts

@@ -0,0 +1,21 @@
+import { UUID } from "crypto";
+import { ManifestInterface, SemverString, Type, Version } from "../../types/objects/Manifest";
+interface ManifestHeader {
+    name: string;
+    description?: string;
+    uuid?: UUID;
+    version?: Version | SemverString;
+}
+interface ManifestMetadata {
+    authors?: Array<string>;
+    license?: string;
+    url?: string;
+    producType?: string;
+    generatedWith?: object;
+}
+export declare class Manifest {
+    manifest: ManifestInterface;
+    constructor(header: ManifestHeader, type?: Type, metadata?: ManifestMetadata);
+    buildJson(): string;
+}
+export {};

package/dist/types/compilers/generator/Save.d.ts

@@ -0,0 +1,16 @@
+import { Class } from "../../components/Class";
+import { UUID } from "../../types/objects/Manifest";
+type ReturnValue = () => any;
+export declare class Save extends Class {
+    static isSaveCreated: boolean;
+    private static write;
+    private static read;
+    static createFile(path: string, data: ReturnValue, write?: Function, read?: Function): any;
+    static createJson(path: string, data: ReturnValue): any;
+    static updateFile(path: string, data: ReturnValue, write?: Function, read?: Function): any;
+    static updateJson(path: string, data: ReturnValue): any;
+    static uuid(): [UUID, UUID];
+    static resource(mcVersion?: "stable" | "preview"): any;
+    static getBuildID(): any;
+}
+export {};

package/dist/types/compilers/generator/SearchFiles.d.ts

@@ -0,0 +1,11 @@
+import { Class } from "../../components/Class";
+interface CallbackValue {
+    folder?: string;
+    file: string;
+    path: string;
+}
+export declare class SearchFiles extends Class {
+    static array(folderPath: string, prefix?: string): Array<string>;
+    static forEach(folderPath: string, callback: (value: CallbackValue) => void): void;
+}
+export {};

package/dist/types/compilers/generator/Sounds.d.ts

@@ -0,0 +1,5 @@
+import { Class } from "../../components/Class";
+export declare class SoundHandler extends Class {
+    static get(path: string): string;
+    static compile(installPath: string): number;
+}

package/dist/types/compilers/generator/Template.d.ts

@@ -0,0 +1 @@
+export declare function firstRun(): void;

package/dist/types/compilers/generator/UIBuilder.d.ts

@@ -0,0 +1,9 @@
+export declare class UIBuilder {
+    static delete(installPath: string): void;
+    static jsonUI(installPath: string): number;
+    static modify(installPath: string): number;
+    static uiDefs(installPath: string): number;
+    static contents(installPath: string): number;
+    static texturesList(installPath: string): number;
+    static globalVariables(installPath: string): number;
+}

package/dist/types/compilers/reader/Audio.d.ts

@@ -0,0 +1 @@
+export declare function FormatAudio(): void;

package/dist/types/compilers/reader/Color.d.ts

@@ -0,0 +1,5 @@
+import { Class } from "../../components/Class";
+import { Vector3, Vector4 } from "../../types/values/Vector";
+export declare class ColorHandler extends Class {
+    static parse(data: string): Vector3 | Vector4 | null;
+}

package/dist/types/compilers/reader/CurrentLine.d.ts

@@ -0,0 +1 @@
+export declare function CurrentLine(): string;

package/dist/types/compilers/reader/Env.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/compilers/reader/GlobalVariables.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/compilers/reader/Object.d.ts

@@ -0,0 +1,11 @@
+import { Class } from "../../components/Class";
+type CallbackObject = (key: string, value: any) => void;
+type CallbackObjectMap = (key: string, value: any) => {
+    key: string;
+    value: any;
+};
+export declare class Obj extends Class {
+    static forEach(data: object, callback: CallbackObject): void;
+    static map(data: object, callback: CallbackObjectMap): object;
+}
+export {};

package/dist/types/compilers/reader/ReadBinding.d.ts

@@ -0,0 +1,6 @@
+import { UI } from "../../components/UI";
+import { BindingName } from "../../types/enums/BindingName";
+import { BindingInterface } from "../../types/objects/BindingInterface";
+import { OverrideInterface } from "../../types/objects/Modify";
+import { Var } from "../../types/values/Variable";
+export declare function ReadBinding(binding: BindingName | Var | BindingInterface, arg: UI | OverrideInterface): BindingInterface;

package/dist/types/compilers/reader/ReadProperties.d.ts

@@ -0,0 +1,3 @@
+import { Properties } from "../../types/objects/properties/Properties";
+export declare function ReadValue(value: any, callback?: (type: string) => any): any;
+export declare function ReadProperties(properties: Properties): Properties;

package/dist/types/components/AddCollectionChill.d.ts

@@ -0,0 +1,6 @@
+import { UIChildNameCallback } from "../types/components/NameCallback";
+import { Properties } from "../types/objects/properties/Properties";
+import { UI } from "./UI";
+type setNameCallback = (index: number) => string;
+export declare function AddCollectionChild(parent: UI, child: UI, collectionLength: number, startIndex?: number, properties?: Properties, setName?: setNameCallback, callback?: UIChildNameCallback): void;
+export {};

package/dist/types/components/Animation.d.ts

@@ -0,0 +1,15 @@
+import { Identifier } from "../types/components/Identifier";
+import { AnimationInterface } from "../types/objects/Animation";
+import { Class } from "./Class";
+export declare class Animation extends Class {
+    private identifier?;
+    private keyFrames;
+    private buildKey;
+    private config;
+    static register(animation: AnimationInterface, identifier?: Identifier): Animation;
+    constructor(animation: AnimationInterface, identifier?: Identifier | undefined);
+    getKeyIndex(index: number): string;
+    private buildAnimation;
+    private generateIdentifier;
+    private getFrameKeyByIdentifier;
+}

package/dist/types/components/AnimationKeyFrame.d.ts

@@ -0,0 +1,10 @@
+import { Identifier } from "../types/components/Identifier";
+import { AnimationKeyFrameInterface } from "../types/objects/Animation";
+import { Class } from "./Class";
+export declare class AnimationKeyFrame extends Class {
+    private identifier;
+    private properties;
+    constructor(keyFrame: AnimationKeyFrameInterface, identifier: Identifier);
+    getFullPath(): string;
+    getUI(): AnimationKeyFrameInterface;
+}

package/dist/types/components/Class.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Represents a class with several static methods and properties that appear to serve as placeholders or utilities.
+ * The methods in this class are defined but not yet implemented, potentially for future extensions or overriding.
+ *
+ * @class Class
+ */
+export declare class Class {
+    /**
+     * A static method that seems to serve as a placeholder, but has no functionality as of now.
+     *
+     * @private
+     * @static
+     */
+    private static apply;
+    /**
+     * A static property initialized to an empty string, likely intended to hold arguments or be overridden in the future.
+     *
+     * @private
+     * @static
+     * @type {string}
+     */
+    private static arguments;
+    /**
+     * A static method that seems to serve as a placeholder, but has no functionality as of now.
+     *
+     * @private
+     * @static
+     */
+    private static bind;
+    /**
+     * A static method that seems to serve as a placeholder, but has no functionality as of now.
+     *
+     * @private
+     * @static
+     */
+    private static call;
+    /**
+     * A static property initialized to an empty string, likely intended to hold caller information or be overridden in the future.
+     *
+     * @private
+     * @static
+     * @type {string}
+     */
+    private static caller;
+    /**
+     * A static property initialized to an empty string, likely intended to hold length-related data or be overridden in the future.
+     *
+     * @private
+     * @static
+     * @type {string}
+     */
+    private static length;
+    /**
+     * A static property initialized to an empty string, likely intended to hold a name or be overridden in the future.
+     *
+     * @private
+     * @static
+     * @type {string}
+     */
+    private static name;
+    /**
+     * A static method that seems to serve as a placeholder, but has no functionality as of now.
+     *
+     * @private
+     * @static
+     */
+    private static toString;
+}

package/dist/types/components/LocalizeText.d.ts

@@ -0,0 +1,21 @@
+import { StaticUIInterface } from "../types/components/UIInterface";
+import { Label } from "../types/objects/elements/Label";
+import { UI } from "./UI";
+interface LocalizeTextInterface {
+    [language: string]: {
+        [key: string]: string;
+    };
+}
+interface SetLocalizeTextInterface {
+    [language: string]: string;
+}
+export declare const localizeText: LocalizeTextInterface;
+export declare class LocalizeText {
+    key: string;
+    constructor(key: string, value: string | SetLocalizeTextInterface);
+    createLabel(properties?: Omit<Label, "text">, identifier?: StaticUIInterface): UI<import("..").Types.Label>;
+    set(texts: SetLocalizeTextInterface): void;
+    get(): string;
+    static register(key: string, value: string | SetLocalizeTextInterface): LocalizeText;
+}
+export {};

package/dist/types/components/Modify.d.ts

@@ -0,0 +1,30 @@
+import { Identifier } from "../types/components/Identifier";
+import { ExtendInterface } from "../types/components/UIInterface";
+import { Types } from "../types/enums/Types";
+import { PropertiesType } from "../types/objects/elements/PropertiesType";
+import { OverrideInterface, ModificationInterface, ExtractUIType } from "../types/objects/Modify";
+import { Properties } from "../types/objects/properties/Properties";
+import { Class } from "./Class";
+import { UI } from "./UI";
+export declare class Modify<T extends Types = Types.Any, K extends string = string> extends Class {
+    private properties;
+    private controls?;
+    private bindings?;
+    private variables?;
+    private isValidPath;
+    name: string;
+    namespace: string;
+    private modifyBindings?;
+    private removeModifyBindings?;
+    private modifyControls;
+    override: OverrideInterface;
+    modify: ModificationInterface<K>;
+    private constructor();
+    getPath(): string;
+    getElement(): string;
+    extend(identifier?: ExtendInterface, properties?: PropertiesType[ExtractUIType<typeof this>]): UI<this extends UI<infer U extends Types> ? U : this extends Modify<infer U_1 extends Types, string> ? U_1 : this extends string ? never : this extends Identifier ? never : never>;
+    getUI(): any;
+    addChild<T extends string | UI<any> | Modify<any, any>>(element: T, properties?: PropertiesType[ExtractUIType<typeof element>], elementName?: string): this;
+    static register<T extends Types = Types.Any, K extends string = string>(filePath: string, elementPath: string, properties?: Properties): Modify<T, K>;
+    static registerWithNamespace<T extends Types = Types.Any, K extends string = string>(filePath: string, elementPath: string, namespace: string, properties?: Properties): Modify<T, K>;
+}

package/dist/types/components/Random.d.ts

@@ -0,0 +1,20 @@
+import { UUID } from "../types/objects/Manifest";
+import { Class } from "./Class";
+import { Binding } from "../types/values/Binding";
+export declare class Random extends Class {
+    private static namespaces?;
+    private static namespaceIndex;
+    private static _uiConfig?;
+    private static get uiConfig();
+    private static get isObfuscate();
+    private static _uniqueKey?;
+    private static get uniqueKey();
+    private static get prefix();
+    private static counter;
+    static genString(length: number, base?: number): string;
+    static getName(length?: number): string;
+    static getAnimationName(length?: number): string;
+    static getNamespace(): string;
+    static getUUID(): UUID;
+    static bindingName(): Binding;
+}

package/dist/types/components/UI.d.ts

@@ -0,0 +1,89 @@
+import { Identifier } from "../types/components/Identifier";
+import { UIChildNameCallback } from "../types/components/NameCallback";
+import { ExtendInterface, StaticUIInterface, UIInterface } from "../types/components/UIInterface";
+import { Renderer } from "../types/enums/Renderer";
+import { Types } from "../types/enums/Types";
+import { BindingInterface } from "../types/objects/BindingInterface";
+import { ButtonMapping } from "../types/objects/ButtonMapping";
+import { Button } from "../types/objects/elements/Button";
+import { CollectionPanel } from "../types/objects/elements/CollectionPanel";
+import { Dropdown } from "../types/objects/elements/Dropdown";
+import { EditBox } from "../types/objects/elements/EditBox";
+import { Grid } from "../types/objects/elements/Grid";
+import { Image } from "../types/objects/elements/Image";
+import { InputPanel } from "../types/objects/elements/InputPanel";
+import { Label } from "../types/objects/elements/Label";
+import { Panel } from "../types/objects/elements/panel";
+import { PropertiesType } from "../types/objects/elements/PropertiesType";
+import { Screen } from "../types/objects/elements/Screen";
+import { ScrollbarBox } from "../types/objects/elements/ScrollbarBox";
+import { ScrollbarTrack } from "../types/objects/elements/ScrollbarTrack";
+import { ScrollView } from "../types/objects/elements/ScrollView";
+import { Slider } from "../types/objects/elements/Slider";
+import { SliderBox } from "../types/objects/elements/SliderBox";
+import { StackPanel } from "../types/objects/elements/StackPanel";
+import { Toggle } from "../types/objects/elements/Toggle";
+import { TooltipTrigger } from "../types/objects/elements/TooltipTrigger";
+import { Specials } from "../types/objects/properties/Specials";
+import { VariablesInterface } from "../types/objects/Variables";
+import { Binding } from "../types/values/Binding";
+import { Animation } from "./Animation";
+import { Modify } from "./Modify";
+type ExtractUIType<T, K extends Types = Types.Any> = T extends UI<infer U> ? U : T extends Modify<infer U> ? U : T extends string ? K : T extends Identifier ? K : never;
+export declare class UI<T extends Types = Types.Any> {
+    name?: string;
+    namespace?: string;
+    extends?: string;
+    sourceBindings: Record<string, string>;
+    private type?;
+    private controls?;
+    private bindings?;
+    private button_mappings?;
+    private variables?;
+    private anims?;
+    private properties?;
+    constructor(identifier: UIInterface | UI | Modify);
+    static panel(properties?: Panel, identifier?: StaticUIInterface): UI<Types.Panel>;
+    static stackPanel(properties?: StackPanel, identifier?: StaticUIInterface): UI<Types.StackPanel>;
+    static collectionPanel(properties?: CollectionPanel, identifier?: StaticUIInterface): UI<Types.CollectionPanel>;
+    static inputPanel(properties?: InputPanel, identifier?: StaticUIInterface): UI<Types.InputPanel>;
+    static grid(properties?: Grid, identifier?: StaticUIInterface): UI<Types.Grid>;
+    static button(properties?: Button, identifier?: StaticUIInterface): UI<Types.Button>;
+    static toggle(properties?: Toggle, identifier?: StaticUIInterface): UI<Types.Toggle>;
+    static label(properties?: Label, identifier?: StaticUIInterface): UI<Types.Label>;
+    static image(properties?: Image, identifier?: StaticUIInterface): UI<Types.Image>;
+    static dropdown(properties?: Dropdown, identifier?: StaticUIInterface): UI<Types.Dropdown>;
+    static slider(properties?: Slider, identifier?: StaticUIInterface): UI<Types.Slider>;
+    static sliderBox(properties?: SliderBox, identifier?: StaticUIInterface): UI<Types.SliderBox>;
+    static editBox(properties?: EditBox, identifier?: StaticUIInterface): UI<Types.EditBox>;
+    static scrollView(properties?: ScrollView, identifier?: StaticUIInterface): UI<Types.ScrollView>;
+    static scrollbarTrack(properties?: ScrollbarTrack, identifier?: StaticUIInterface): UI<Types.ScrollbarTrack>;
+    static scrollbarBox(properties?: ScrollbarBox, identifier?: StaticUIInterface): UI<Types.ScrollbarBox>;
+    static screen(properties?: Screen, identifier?: StaticUIInterface): UI<Types.Screen>;
+    static custom<T extends Renderer>(renderer: T, properties?: Panel | Specials[T], identifier?: StaticUIInterface): UI<Types.Custom>;
+    static tooltipTrigger(properties?: TooltipTrigger, identifier?: StaticUIInterface): UI<Types.TooltipTrigger>;
+    static extend<K extends Types = Types.Any, T extends string | Identifier | UI | Modify = UI>(extendElement?: T, properties?: PropertiesType[ExtractUIType<typeof extendElement, K>], identifier?: StaticUIInterface): UI<ExtractUIType<T, K>>;
+    searchBinding(bindingName: Binding, controlName?: string, targetBindingName?: Binding): Binding | undefined;
+    setProperties(properties: PropertiesType[T]): this;
+    private isDuplicate;
+    private isRecusive;
+    addChild<K extends Types = Types.Any, T extends string | Identifier | UI | Modify = any>(element: T, properties?: PropertiesType[ExtractUIType<typeof element, K>] | null | 0, name?: string | null | 0, callback?: UIChildNameCallback): this;
+    addBindings(bindings: Array<BindingInterface> | BindingInterface): this;
+    addVariables(variables: VariablesInterface): this;
+    getUI(): any;
+    getPath(): string;
+    getElement(): string;
+    getFullPath(): string;
+    extend(identifier?: ExtendInterface, properties?: PropertiesType[T]): UI<T>;
+    addAnimation(animation: Animation, startIndex?: number): this;
+    addMapping(mapping: Array<ButtonMapping> | ButtonMapping): this;
+    private static apply;
+    private static arguments;
+    private static bind;
+    private static call;
+    private static caller;
+    private static length;
+    private static name;
+    private static toString;
+}
+export {};