@acrodata/gui/index.d.ts

JSON powered GUI for configurable panels.

import * as i0 from '@angular/core';
import { OnChanges, OnInit, OnDestroy, EventEmitter, SimpleChanges, DoCheck, AfterViewInit, ElementRef, PipeTransform, InjectionToken } from '@angular/core';
import * as i1 from '@angular/common';
import * as i2 from '@angular/forms';
import { FormGroup, FormArray, ControlValueAccessor } from '@angular/forms';
import * as i3 from '@angular/material/form-field';
import * as i4 from '@angular/material/input';
import * as i5 from '@angular/material/select';
import * as i6 from '@angular/material/slider';
import * as i7 from '@angular/material/slide-toggle';
import * as i8 from '@angular/material/button-toggle';
import * as i9 from '@angular/material/icon';
import * as i10 from '@angular/material/button';
import * as i11 from '@angular/material/tabs';
import * as i12 from '@angular/material/expansion';
import * as i13 from '@angular/material/tooltip';
import * as i14 from '@ng-matero/extensions/colorpicker';
import * as i15 from '@ng-matero/extensions/select';
import { MtxSelect } from '@ng-matero/extensions/select';
import * as rxjs from 'rxjs';
import { Subscription, Subject } from 'rxjs';
import * as _codemirror_state from '@codemirror/state';
import { Extension } from '@codemirror/state';
import * as _acrodata_code_editor from '@acrodata/code-editor';
import { Setup, Theme } from '@acrodata/code-editor';
import * as _codemirror_language from '@codemirror/language';
import { LanguageDescription } from '@codemirror/language';
import { HttpClient } from '@angular/common/http';

type GuiFieldType = 'group' | 'inline' | 'tabs' | 'tab' | 'menu' | 'menuItem' | 'text' | 'number' | 'switch' | 'slider' | 'fill' | 'select' | 'buttonToggle' | 'imageSelect' | 'combobox' | 'textarea' | 'codearea' | 'hidden' | 'image' | 'video' | 'audio' | 'file';
type GuiFillMode = 'all' | 'solid' | 'gradient' | 'image';
type GuiSliderMode = 'normal' | 'range';
type GuiTabsMode = 'normal' | 'list';
type GuiBasicValue = boolean | number | string;
type GuiDefaultValue = boolean | number | string | any[] | Record<string, any> | null;
type GuiOperator = '$eq' | '$ne' | '$gt' | '$lt' | '$gte' | '$lte' | '$in' | '$nin';
type GuiCondition = [string, GuiOperator, GuiDefaultValue];
interface GuiFieldShowIf {
    conditions: GuiCondition[];
    logicalType?: '$and' | '$or';
}
interface GuiField {
    type: GuiFieldType;
    name: string;
    default?: GuiDefaultValue;
    description?: string;
    placeholder?: string;
    disabled?: boolean;
    col?: number;
    showIf?: GuiFieldShowIf;
    show?: boolean;
    children?: GuiFields | GuiField[];
    expanded?: boolean;
    min?: number;
    max?: number;
    step?: number;
    prefix?: string;
    suffix?: string;
    options?: GuiFieldOption[];
    useFont?: boolean;
    multiple?: boolean;
    useIcon?: boolean;
    template?: Partial<GuiField>;
    addable?: boolean;
    mode?: GuiFillMode | GuiSliderMode | GuiTabsMode;
    rows?: number;
    accept?: string;
    height?: string | number;
    language?: string;
}
type GuiFields = Record<string, GuiField>;
interface GuiFieldOption {
    label: string;
    value: string | number | boolean;
    disabled?: boolean;
    src?: string;
    col?: number;
}
interface GuiControl extends GuiField {
    _type: 'control' | 'group' | 'array';
    key: string;
    parentType: GuiFieldType;
    model?: any;
    default?: any;
    index?: number;
    children?: GuiControl[];
    template?: Partial<GuiControl>;
    selectedIndex?: number;
}
type GuiControls = Record<string, GuiControl>;

declare class GuiForm implements OnChanges, OnInit, OnDestroy {
    /**
     * The form instance which allow to track model value and validation status.
     */
    form: FormGroup<any>;
    /**
     * The field configurations for building the form.
     */
    config: GuiFields;
    /**
     * The model to be represented by the form.
     */
    model: Record<string, any>;
    /**
     * Fired on model value change
     */
    modelChange: EventEmitter<any>;
    formFields: GuiControl[];
    formSubscription: Subscription;
    controlSubscriptions: Subscription[];
    uid: string;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Convert the object config to array config and register into the reactive form.
     *
     * @param form         The reactive form instance
     * @param config       The config of the form fields
     * @param model        The value of the form control
     * @param defaultValue The default value of the form field
     * @param parentType   The type of the form field parent
     * @returns
     */
    getFormFieldArray(form: FormGroup | FormArray, config?: GuiFields | GuiControl[], model?: Record<string, any>, defaultValue?: any, parentType?: GuiFieldType): GuiControl[];
    /**
     * Add a tab item.
     *
     * @param e         The mouse event
     * @param formArray The reactive form instance
     * @param tabs      The config of the tabs field
     * @param copy      Whether to copy the current tab
     * @param index     The index of the tabs array
     */
    addTab(e: MouseEvent, formArray: FormArray, tabs: GuiControl, copy?: boolean, index?: number): void;
    /**
     * Remove a tab item.
     *
     * @param e         The mouse event
     * @param formArray The reactive form instance
     * @param tabs      The config of the tabs field
     * @param index     The index of the tabs array
     */
    removeTab(e: MouseEvent, formArray: FormArray, tabs: GuiControl, index?: number): void;
    /**
     * Change the display mode of tabs.
     *
     * @param e    The mouse event
     * @param tabs The config of the tabs field
     * @param mode The display mode of tabs
     */
    changeTabsMode(e: MouseEvent, tabs: GuiControl, mode?: GuiTabsMode): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiForm, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiForm, "gui-form", never, { "form": { "alias": "form"; "required": false; }; "config": { "alias": "config"; "required": false; }; "model": { "alias": "model"; "required": false; }; }, { "modelChange": "modelChange"; }, never, never, true, never>;
}

declare class GuiInputText implements ControlValueAccessor {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    value: string;
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiInputText, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiInputText, "gui-input-text", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiInputNumber implements ControlValueAccessor {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    value: number;
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiInputNumber, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiInputNumber, "gui-input-number", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiSelect implements ControlValueAccessor {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    value: GuiBasicValue | GuiBasicValue[];
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: GuiBasicValue | GuiBasicValue[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiSelect, "gui-select", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiSwitch implements ControlValueAccessor {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    value: boolean;
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: boolean) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiSwitch, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiSwitch, "gui-switch", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiSlider implements ControlValueAccessor {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    value: number | number[];
    minValue: number;
    maxValue: number;
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: number | number[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    onRangeSliderChange(): void;
    onRangeInputChange(): void;
    setInputValue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiSlider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiSlider, "gui-slider", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiIcon {
    src: string;
    get isUrl(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiIcon, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiIcon, "gui-icon", never, { "src": { "alias": "src"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiButtonToggle implements ControlValueAccessor {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    value: GuiBasicValue | GuiBasicValue[];
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: GuiBasicValue | GuiBasicValue[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiButtonToggle, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiButtonToggle, "gui-button-toggle", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiFill implements ControlValueAccessor, OnChanges {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    type: GuiFillMode;
    value: string;
    private onChange;
    private onTouched;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiFill, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiFill, "gui-fill", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiFillPicker implements ControlValueAccessor, OnChanges {
    private cdr;
    disabled: boolean;
    type: GuiFillMode;
    types: {
        label: string;
        value: string;
    }[];
    selectedType: Exclude<GuiFillMode, 'all'>;
    fillValue: {
        solid: string;
        gradient: string;
        image: string;
    };
    private onChange;
    private onTouched;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    getTypeFromModel(value: string): void;
    getValueFromModel(value: string): void;
    onTypeChange(): void;
    onColorChange(): void;
    onSolidChange(): void;
    onGradientChange(): void;
    onImageChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiFillPicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiFillPicker, "gui-fill-picker", never, { "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiFieldGroup implements OnInit, DoCheck {
    private differs;
    private cdr;
    config: Partial<GuiControl>;
    private configDiffer?;
    ngOnInit(): void;
    ngDoCheck(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiFieldGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiFieldGroup, "gui-field-group", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class GuiFieldLabel implements OnChanges {
    config: Partial<GuiControl>;
    index?: number;
    title: string;
    styless: boolean;
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiFieldLabel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiFieldLabel, "gui-field-label", never, { "config": { "alias": "config"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiInlineGroup {
    config: Partial<GuiControl>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiInlineGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiInlineGroup, "gui-inline-group", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class GuiImageSelect implements ControlValueAccessor, AfterViewInit {
    private cdr;
    mtxSelect: MtxSelect;
    config: Partial<GuiControl>;
    disabled: boolean;
    appendTo: string;
    value: any;
    private onChange;
    private onTouched;
    ngAfterViewInit(): void;
    writeValue(value: any): void;
    registerOnChange(fn: (value: any) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiImageSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiImageSelect, "gui-image-select", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiCombobox implements ControlValueAccessor, AfterViewInit {
    private cdr;
    mtxSelect: MtxSelect;
    config: Partial<GuiControl>;
    disabled: boolean;
    appendTo: string;
    value: GuiBasicValue | GuiBasicValue[];
    private onChange;
    private onTouched;
    ngAfterViewInit(): void;
    writeValue(value: any): void;
    registerOnChange(fn: (value: GuiBasicValue | GuiBasicValue[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    addTagFn(label: string): {
        label: string;
        value: string;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiCombobox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiCombobox, "gui-combobox", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GuiTextarea {
    private cdr;
    config: Partial<GuiControl>;
    disabled: boolean;
    value: string;
    private onChange;
    private onTouched;
    writeValue(value: any): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiTextarea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiTextarea, "gui-textarea", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

interface GuiCodeareaDialogData {
    value: string;
    disabled?: boolean;
    readonly?: boolean;
    language?: string;
    title?: string;
}
declare class GuiCodeareaDialog {
    private dialogRef;
    data: GuiCodeareaDialogData;
    private cdr;
    private destroyRef;
    private codeareaCfg;
    get languages(): _codemirror_language.LanguageDescription[];
    get theme(): _acrodata_code_editor.Theme;
    get extensions(): _codemirror_state.Extension[];
    langDesc: _codemirror_language.LanguageDescription | undefined;
    title: string;
    lineWrapping: boolean;
    constructor();
    toggleLineWrapping(): void;
    save(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiCodeareaDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiCodeareaDialog, "gui-codearea-dialog", never, {}, {}, never, never, true, never>;
}

declare class GuiCodearea implements ControlValueAccessor {
    private rndDialog;
    private cdr;
    private destroyRef;
    private codeareaCfg;
    config: Partial<GuiControl>;
    disabled: boolean;
    setup: Setup;
    get height(): string | number;
    set height(value: string | number);
    private _height;
    get language(): string;
    set language(value: string);
    private _language;
    get languages(): _codemirror_language.LanguageDescription[];
    get theme(): _acrodata_code_editor.Theme;
    get dialogData(): GuiCodeareaDialogData;
    get extensions(): _codemirror_state.Extension[];
    value: string;
    private oldValue;
    private onChange;
    private onTouched;
    constructor();
    writeValue(value: any): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onValueChange(): void;
    onExpand(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiCodearea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiCodearea, "gui-codearea", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "setup": { "alias": "setup"; "required": false; }; "height": { "alias": "height"; "required": false; }; "language": { "alias": "language"; "required": false; }; }, {}, never, never, true, never>;
}

type FileUploadType = 'image' | 'video' | 'audio' | '*';
interface FileUploadContent {
    data: File;
    progress: number;
    inProgress: boolean;
}
declare class GuiFileUploader implements ControlValueAccessor, OnChanges {
    private fileUploaderCfg;
    private cdr;
    fileInput: ElementRef<HTMLInputElement>;
    config: Partial<GuiControl>;
    disabled: boolean;
    type: FileUploadType;
    name: string;
    accept: string;
    fileChange: EventEmitter<string>;
    url: string;
    fileUpload: FileUploadContent;
    private onChange;
    private onTouched;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    upload(fileUpload: FileUploadContent): void;
    onUrlChange(e: Event): void;
    onFileChange(e: Event): void;
    onBlur(): void;
    onClear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiFileUploader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiFileUploader, "gui-file-uploader", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "name": { "alias": "name"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; }, { "fileChange": "fileChange"; }, never, never, true, never>;
}

declare class GuiIconButtonWrapper {
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiIconButtonWrapper, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GuiIconButtonWrapper, "gui-icon-button-wrapper", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Lightweight EJS template engine
 *
 * @param str  template string
 * @param data data passed to the template
 * @returns
 *
 * ### Example
 *
 * ```ts
 * const people = ['geddy', 'neil', 'alex'];
 * const res = ejsTmpl('<%= people.join(", ") %>', {people: people});
 * console.log(res);
 * // => 'geddy, neil, alex'
 * ```
 *
 */
declare function ejsTmpl(str: string, data: any): any;
declare class GuiEjsPipe implements PipeTransform {
    transform(value: string, data?: {}): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiEjsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GuiEjsPipe, "ejs", true>;
}
declare class GuiFlexDirective implements OnInit {
    private el;
    flex: number | undefined;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiFlexDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GuiFlexDirective, "[flex]", never, { "flex": { "alias": "flex"; "required": false; }; }, {}, never, never, true, never>;
}
declare function compareValues(a: GuiDefaultValue, b: GuiDefaultValue, operator: GuiOperator): boolean;
declare function getValueByPath(obj: Record<string, any>, path: string): Record<string, any> | undefined;
declare function getModelFromConfig(config?: GuiFields, model?: Record<string, any>): Record<string, any>;

declare class GuiModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GuiModule, never, [typeof i1.CommonModule, typeof i2.ReactiveFormsModule, typeof i2.FormsModule, typeof i3.MatFormFieldModule, typeof i4.MatInputModule, typeof i5.MatSelectModule, typeof i6.MatSliderModule, typeof i7.MatSlideToggleModule, typeof i8.MatButtonToggleModule, typeof i9.MatIconModule, typeof i10.MatButtonModule, typeof i11.MatTabsModule, typeof i12.MatExpansionModule, typeof i13.MatTooltipModule, typeof i14.MtxColorpickerModule, typeof i15.MtxSelectModule, typeof GuiForm, typeof GuiInputText, typeof GuiInputNumber, typeof GuiSelect, typeof GuiSwitch, typeof GuiSlider, typeof GuiIcon, typeof GuiButtonToggle, typeof GuiFill, typeof GuiFillPicker, typeof GuiFieldGroup, typeof GuiFieldLabel, typeof GuiInlineGroup, typeof GuiImageSelect, typeof GuiCombobox, typeof GuiTextarea, typeof GuiCodearea, typeof GuiCodeareaDialog, typeof GuiFileUploader, typeof GuiIconButtonWrapper, typeof GuiEjsPipe, typeof GuiFlexDirective], [typeof GuiForm, typeof GuiInputText, typeof GuiInputNumber, typeof GuiSelect, typeof GuiSwitch, typeof GuiSlider, typeof GuiIcon, typeof GuiButtonToggle, typeof GuiFill, typeof GuiFillPicker, typeof GuiFieldGroup, typeof GuiFieldLabel, typeof GuiInlineGroup, typeof GuiImageSelect, typeof GuiCombobox, typeof GuiTextarea, typeof GuiCodearea, typeof GuiCodeareaDialog, typeof GuiFileUploader, typeof GuiIconButtonWrapper, typeof GuiEjsPipe, typeof GuiFlexDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GuiModule>;
}

declare class GuiCodeareaConfig {
    readonly changes: Subject<void>;
    theme: Theme;
    languages: LanguageDescription[];
    extensions: Extension[] | ((data: GuiCodeareaDialogData) => Extension[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiCodeareaConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GuiCodeareaConfig>;
}

interface FileUploadResponseBody {
    bytes: number;
    mime: string;
    url: string;
}
declare class GuiFileUploaderConfig {
    protected http: HttpClient;
    /**
     *  The file upload URL
     */
    url: string;
    /**
     * The File upload API
     *
     * @param formData The FormData with file binary
     * @param config   The custom upload config that passed from component input
     * @returns        The uploaded file url stream
     */
    upload(formData: FormData, config: Partial<GuiControl>): rxjs.Observable<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiFileUploaderConfig, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GuiFileUploaderConfig>;
}

declare const svgIcons: {
    horizontal: string;
    vertical: string;
    add: string;
    delete: string;
    copy: string;
    link: string;
    clear: string;
    file: string;
    upload: string;
    expand: string;
    wrap: string;
    solid: string;
    gradient: string;
    image: string;
};
type GuiIconType = keyof typeof svgIcons;
type GuiIconsConfig = Record<GuiIconType, string>;
/** Injection token that can be used to provide the default icons. */
declare const GUI_ICONS_CONFIG: InjectionToken<GuiIconsConfig>;
declare class GuiIconsRegistry {
    private _iconRegistry;
    private _sanitizer;
    private _defaultIcons;
    add(...iconNames: GuiIconType[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GuiIconsRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GuiIconsRegistry>;
}

export { GUI_ICONS_CONFIG, GuiButtonToggle, GuiCodearea, GuiCodeareaConfig, GuiCodeareaDialog, GuiCombobox, GuiEjsPipe, GuiFieldGroup, GuiFieldLabel, GuiFileUploader, GuiFileUploaderConfig, GuiFill, GuiFillPicker, GuiFlexDirective, GuiForm, GuiIcon, GuiIconButtonWrapper, GuiIconsRegistry, GuiImageSelect, GuiInlineGroup, GuiInputNumber, GuiInputText, GuiModule, GuiSelect, GuiSlider, GuiSwitch, GuiTextarea, compareValues, ejsTmpl, getModelFromConfig, getValueByPath, svgIcons };
export type { FileUploadContent, FileUploadResponseBody, FileUploadType, GuiBasicValue, GuiCodeareaDialogData, GuiCondition, GuiControl, GuiControls, GuiDefaultValue, GuiField, GuiFieldOption, GuiFieldShowIf, GuiFieldType, GuiFields, GuiFillMode, GuiIconType, GuiIconsConfig, GuiOperator, GuiSliderMode, GuiTabsMode };