ui-core-abv 0.0.0-watch

package/lib/components/work-panel/work-panel.component.d.ts

@@ -0,0 +1,63 @@
+import { AfterViewInit, ChangeDetectorRef, ComponentRef, EventEmitter, Type, ViewContainerRef } from '@angular/core';
+import { AlertData } from '../tiny-alert/tiny-alert.model';
+import { ActionMenuOption } from '../uic-action-button/uic-action-button.component';
+import * as i0 from "@angular/core";
+export interface WorkPanelTabConfig {
+    id?: string;
+    title?: string;
+    label: string;
+    icon?: string;
+    componentType: Type<any>;
+    componentInputs?: Record<string, any>;
+}
+export declare class UicWorkPanelComponent implements AfterViewInit {
+    private readonly cdr;
+    host: ViewContainerRef;
+    private readonly tinyAlert;
+    moreActions: ActionMenuOption[];
+    actionSelected: EventEmitter<ActionMenuOption & {
+        panelId: string;
+    }>;
+    componentType?: Type<any>;
+    componentInputs: Record<string, any>;
+    tabs: WorkPanelTabConfig[];
+    closeWarning: AlertData;
+    width: string;
+    duplicateValidationMessage: string;
+    tabsChange: EventEmitter<WorkPanelTabConfig[]>;
+    tabClosed: EventEmitter<string>;
+    tabSelected: EventEmitter<string>;
+    tabAdded: EventEmitter<string>;
+    fullViewChange: EventEmitter<boolean>;
+    minPosition: number;
+    showAddButton: boolean;
+    fullView: boolean;
+    isMinimized: boolean;
+    activeTabId?: string;
+    activeTabTitle?: string;
+    tabInstances: Array<WorkPanelTabConfig & {
+        id: string;
+        componentRef: ComponentRef<any>;
+    }>;
+    private idCounter;
+    private initialized;
+    constructor(cdr: ChangeDetectorRef);
+    get panelWidth(): string;
+    ngAfterViewInit(): void;
+    private initializeTabs;
+    changeSizeBtn(b: boolean): void;
+    addTab(tabConfig: WorkPanelTabConfig): string;
+    openTab(id: string): void;
+    selectTab(id: string): void;
+    closeActiveTab(omitWarning?: boolean): string | undefined;
+    closeTab(id: string, omitWarning?: boolean): void;
+    private destroyPanel;
+    minimizePanel(): void;
+    emitAction(option: ActionMenuOption): void;
+    private createTab;
+    private renderActiveTab;
+    private emitTabsChange;
+    private isFullViewActivated;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicWorkPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UicWorkPanelComponent, "ui-work-panel", never, { "moreActions": { "alias": "moreActions"; "required": false; }; "componentType": { "alias": "componentType"; "required": false; }; "componentInputs": { "alias": "componentInputs"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "closeWarning": { "alias": "closeWarning"; "required": false; }; "width": { "alias": "width"; "required": false; }; "duplicateValidationMessage": { "alias": "duplicateValidationMessage"; "required": false; }; "minPosition": { "alias": "minPosition"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; }, { "actionSelected": "actionSelected"; "tabsChange": "tabsChange"; "tabClosed": "tabClosed"; "tabSelected": "tabSelected"; "tabAdded": "tabAdded"; "fullViewChange": "fullViewChange"; }, never, never, true, never>;
+}

package/lib/directives/textarea-autoresize-max-rows.directive.d.ts

@@ -0,0 +1,9 @@
+import { UicTextareaAutoresizeDirective } from './textarea-autoresize.directive';
+import * as i0 from "@angular/core";
+export declare class UicTextareaAutoresizeMaxRowsDirective {
+    private readonly autosize;
+    constructor(autosize: UicTextareaAutoresizeDirective);
+    set textareaAutoresizeMaxRows(value: number | string | null | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTextareaAutoresizeMaxRowsDirective, [{ optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UicTextareaAutoresizeMaxRowsDirective, "[textareaAutoresizeMaxRows]", never, { "textareaAutoresizeMaxRows": { "alias": "textareaAutoresizeMaxRows"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/directives/textarea-autoresize-min-rows.directive.d.ts

@@ -0,0 +1,9 @@
+import { UicTextareaAutoresizeDirective } from './textarea-autoresize.directive';
+import * as i0 from "@angular/core";
+export declare class UicTextareaAutoresizeMinRowsDirective {
+    private readonly autosize;
+    constructor(autosize: UicTextareaAutoresizeDirective);
+    set textareaAutoresizeMinRows(value: number | string | null | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTextareaAutoresizeMinRowsDirective, [{ optional: true; host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UicTextareaAutoresizeMinRowsDirective, "[textareaAutoresizeMinRows]", never, { "textareaAutoresizeMinRows": { "alias": "textareaAutoresizeMinRows"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/directives/textarea-autoresize.directive.d.ts

@@ -0,0 +1,29 @@
+import { AfterViewInit, DoCheck, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class UicTextareaAutoresizeDirective implements AfterViewInit, DoCheck {
+    private readonly elementRef;
+    private _minRows;
+    private _maxRows;
+    private initialRows;
+    private lastValue;
+    private enabled;
+    constructor(elementRef: ElementRef<HTMLTextAreaElement>);
+    set minRows(value: number | string | null | undefined);
+    set maxRows(value: number | string | null | undefined);
+    set textareaAutoresize(value: boolean | string | null | undefined);
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    onInput(): void;
+    onWindowResize(): void;
+    private resizeToFitContent;
+    private getLineHeight;
+    private parseCssValue;
+    private measureLineHeight;
+    setMinRows(value: number | string | null | undefined): void;
+    setMaxRows(value: number | string | null | undefined): void;
+    private resetStyles;
+    private coerceNumber;
+    private coerceBoolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTextareaAutoresizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UicTextareaAutoresizeDirective, "[textareaAutoresize]", never, { "minRows": { "alias": "minRows"; "required": false; }; "maxRows": { "alias": "maxRows"; "required": false; }; "textareaAutoresize": { "alias": "textareaAutoresize"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/directives/tool-tip.directive.d.ts

@@ -0,0 +1,18 @@
+import { ApplicationRef, ElementRef, EnvironmentInjector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class UicToolTipDirective {
+    private readonly elementRef;
+    private readonly appRef;
+    private readonly injector;
+    tip: string;
+    private componentRef;
+    constructor(elementRef: ElementRef, appRef: ApplicationRef, injector: EnvironmentInjector);
+    onMouseEnter(): void;
+    private canShowTooltipOnHover;
+    private setTooltipComponentProperties;
+    onMouseLeave(): void;
+    ngOnDestroy(): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicToolTipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UicToolTipDirective, "[uiTooltip]", never, { "tip": { "alias": "uiTooltip"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/helpers.d.ts

@@ -0,0 +1,8 @@
+import { EditableBlock, FormBlock, TableColums, TableRowData } from "../public-api";
+export declare function helperTableMapDatoToColums(data: Record<string, any>, headers: TableColums[]): TableRowData[];
+export declare function helperFormMapFormdataToObject<T extends object>(formData: Record<string, any>, defaults: T): T;
+export declare function isMobile(): boolean;
+export declare function helperShowFormFromBuilder(blocks: EditableBlock[], cols: number, editable?: boolean): {
+    cols: number;
+    blocks: FormBlock[];
+};

package/lib/pipes/first-capital.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FirstCapitalPipe implements PipeTransform {
+    transform(str: string, max?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirstCapitalPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FirstCapitalPipe, "firstCapital", true>;
+}

package/lib/pipes/name-inits.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class UicNameInitsPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicNameInitsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UicNameInitsPipe, "nameInitials", true>;
+}

package/lib/pipes/translate.pipe.d.ts

@@ -0,0 +1,11 @@
+import { OnDestroy, PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class UicTranslatePipe implements PipeTransform, OnDestroy {
+    private readonly translateService;
+    private readonly cdr;
+    private readonly subscription;
+    transform(keyOrText: string | null | undefined, params?: Record<string, string | number | null | undefined>): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UicTranslatePipe, "uicTranslate", true>;
+}

package/lib/services/modaRef.d.ts

@@ -0,0 +1,15 @@
+import { OverlayRef } from "@angular/cdk/overlay";
+import { Observable } from "rxjs";
+import { UicModalService } from "./modal.service";
+export declare class UiModalRef<T = any> {
+    private readonly overlayRef;
+    private readonly modalService;
+    private readonly _afterClosed;
+    constructor(overlayRef: OverlayRef, modalService: UicModalService);
+    close(result?: T | null): void;
+    closeFloating(result?: T | null): void;
+    afterClosed(): Observable<{
+        status: boolean;
+        data: T | null;
+    }>;
+}

package/lib/services/modal.constant.d.ts

@@ -0,0 +1,5 @@
+export declare const MODAL_DATA = "MODAL_DATA";
+export declare const MODAL_COMPONENT = "MODAL_COMPONENT";
+export declare const MODAL_CONFIG = "MODAL_CONFIG";
+export declare const MODAL_CLOSE_EVENT = "modalClosed";
+export declare const MODAL_CLOSE_REQUEST = "modalCloserRequested";

package/lib/services/modal.service.d.ts

@@ -0,0 +1,22 @@
+import { Type } from '@angular/core';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { UiModalRef } from './modaRef';
+import { ModalConfig } from '../components/modal/floating-modal/modalconfig.model';
+import { SideModalConfig } from '../components/modal/side-modal/sideModalConfig.model';
+import * as i0 from "@angular/core";
+export declare class UicModalService {
+    private readonly overlay;
+    private readonly envInjector;
+    openFloatingModal<TComponent>(component: Type<TComponent>, config?: ModalConfig): UiModalRef;
+    openSideModal<TComponent>(component: Type<TComponent>, config?: SideModalConfig): UiModalRef;
+    private openModal;
+    close(overlayRef: OverlayRef, result?: any): void;
+    closeFloating(overlayRef: OverlayRef, result?: any): void;
+    private readonly _save$;
+    save$: import("rxjs").Observable<boolean>;
+    triggerSave(result?: boolean): void;
+    private createOverlayConfig;
+    private createModalInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UicModalService>;
+}

package/lib/services/push-alert.service.d.ts

@@ -0,0 +1,13 @@
+import { Alert, AlertConfigParams } from '../components/push-alerts/alert.model';
+import * as i0 from "@angular/core";
+export declare class UicPushAlertService {
+    autoIncId: number;
+    private readonly alerts$;
+    get stream(): import("rxjs").Observable<Alert>;
+    show(alertData: AlertConfigParams): void;
+    success(message: string, options?: Partial<Alert>): void;
+    error(message: string, options?: Partial<Alert>): void;
+    warning(message: string, options?: Partial<Alert>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicPushAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UicPushAlertService>;
+}

package/lib/services/tiny-alert.service.d.ts

@@ -0,0 +1,13 @@
+import { AlertData, AlertResponse } from '../components/tiny-alert/tiny-alert.model';
+import * as i0 from "@angular/core";
+export declare class UicTinyAlertService {
+    private readonly modal;
+    showAlert(data: AlertData): Promise<AlertResponse>;
+    success(message: string, options?: Partial<AlertData>): Promise<AlertResponse>;
+    error(message: string, options?: Partial<AlertData>): Promise<AlertResponse>;
+    warning(message: string, options?: Partial<AlertData>): Promise<AlertResponse>;
+    info(message: string, options?: Partial<AlertData>): Promise<AlertResponse>;
+    deleteConfirmation(message: string, options?: Partial<AlertData>): Promise<AlertResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTinyAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UicTinyAlertService>;
+}

package/lib/services/translate.service.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export type UicLanguage = 'es' | 'en';
+export interface UicTranslateConfig {
+    defaultLanguage?: UicLanguage;
+}
+export declare const UIC_TRANSLATE_CONFIG: InjectionToken<UicTranslateConfig>;
+export declare function provideUicTranslateConfig(config: UicTranslateConfig): Provider;
+export declare class UicTranslateService {
+    private readonly languageState;
+    private readonly dictionaries;
+    constructor(config?: UicTranslateConfig);
+    get language$(): Observable<UicLanguage>;
+    get language(): UicLanguage;
+    setLanguage(language: UicLanguage): void;
+    translate(keyOrText: string | null | undefined, params?: Record<string, string | number | null | undefined>): string;
+    private resolve;
+    private interpolate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UicTranslateService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UicTranslateService>;
+}

package/lib/translate/dictionary.en.d.ts

@@ -0,0 +1,290 @@
+export declare const DICTIONARY_EN: {
+    readonly common: {
+        readonly open: "Open";
+        readonly close: "Close";
+        readonly save: "Save";
+        readonly clear: "Clear";
+        readonly cancel: "Cancel";
+        readonly apply: "Apply";
+        readonly continue: "Continue";
+        readonly back: "Back";
+        readonly next: "Next";
+        readonly send: "Send";
+        readonly today: "Today";
+        readonly search: "Search";
+        readonly search_ellipsis: "Search...";
+        readonly all: "All";
+        readonly select: "Select";
+        readonly selected: "Selected";
+        readonly detail: "Detail";
+    };
+    readonly table: {
+        readonly search_label: "Search";
+        readonly search_placeholder: "Search";
+        readonly empty: "No items found";
+        readonly next_short: "Next";
+        readonly previous_short: "Prev";
+    };
+    readonly select: {
+        readonly non_selected: "- Select -";
+        readonly multy_non_selected: "-- Select --";
+        readonly multy_all_selected: "-- All --";
+        readonly none: "- None -";
+        readonly empty: "No items to show";
+        readonly without_options: "No options available";
+        readonly pending_text: "PENDING TEXT";
+        readonly search_placeholder: "Search...";
+    };
+    readonly tree: {
+        readonly search_label: "Search subcategories:";
+        readonly search_placeholder: "Search...";
+        readonly empty: "No subcategories";
+        readonly duplicate_name: "Subcategory already exists";
+        readonly without_children: "No children";
+    };
+    readonly tag_selector: {
+        readonly add_tag: "Add tag";
+        readonly predefined_title: "Predefined tags";
+        readonly new_tag_title: "New tag";
+    };
+    readonly phone_input: {
+        readonly placeholder: "Enter a number";
+        readonly search_country: "Search country or code";
+        readonly clear_search: "Clear search";
+        readonly no_results: "No results found";
+        readonly aria_country_code: "{{country}} code {{dialCode}}";
+    };
+    readonly time_picker: {
+        readonly placeholder: "hh:mm am/pm";
+    };
+    readonly excel_table: {
+        readonly load_file: "Upload excel";
+        readonly empty_message: "No data to show";
+        readonly clear_file: "Clear";
+        readonly see_more: "See more";
+        readonly counter_text: "Viewing {{shown}} items of {{total}} total";
+    };
+    readonly editable_table: {
+        readonly add_row_above: "Add row above";
+        readonly add_row_below: "Add row below";
+        readonly delete_row: "Delete row";
+        readonly add_column: "Add column";
+        readonly delete_column: "Delete column";
+        readonly delete_row_with_data_warning: "This row has data. If you delete it, all values will be lost.";
+        readonly delete_column_with_data_warning: "The column \"{{column_name}}\" has data. If you delete it, these values will be lost.";
+        readonly save_or_discard_column: "Do you want to save this new column or delete it?";
+        readonly save_column: "Save column";
+        readonly save: "Save";
+        readonly delete: "Delete";
+        readonly column_name_must_be_unique: "Column name must be unique";
+    };
+    readonly rule_builder: {
+        readonly title: "Rule";
+        readonly add_rule: "Condition";
+        readonly add_rule_tip: "Add condition";
+        readonly add_group: "Group";
+        readonly add_group_tip: "Add group";
+        readonly reset: "Reset";
+        readonly reset_tip: "Discard unsaved changes";
+        readonly save: "Save rule";
+        readonly save_tip: "Save built rule";
+        readonly delete_rule_tip: "Delete condition";
+        readonly delete_group_tip: "Delete group";
+        readonly toggle_operator_tip: "Click to change operator";
+        readonly no_rules: "No conditions added";
+        readonly rules_management: "Select condition";
+        readonly edit: "Edit rule";
+        readonly edit_tip: "Edit rule";
+        readonly edit_condition_tip: "Click to edit condition";
+        readonly select_condition: "- select condition -";
+        readonly operators: {
+            readonly and: "AND";
+            readonly or: "OR";
+        };
+        readonly validation: {
+            readonly single_condition_not_allowed: "Rules cannot be created with a single condition";
+        };
+        readonly definition: {
+            readonly cancel_and_back: "Cancel and go back";
+            readonly create_and_select: "Create and select condition";
+            readonly search_placeholder: "Search condition";
+            readonly new_rule: "New condition";
+            readonly no_results: "No conditions found";
+            readonly previous: "Previous";
+            readonly next: "Next";
+            readonly form: {
+                readonly description: "Description";
+                readonly field: "Field";
+                readonly operator: "Operator";
+                readonly value: "Value";
+            };
+        };
+    };
+    readonly step_form: {
+        readonly back: "Back";
+        readonly next: "Next";
+        readonly submit: "Send";
+    };
+    readonly work_panel: {
+        readonly minimize: "Minimize";
+        readonly expand: "Expand";
+        readonly reduce: "Reduce";
+        readonly close: "Close";
+    };
+    readonly modal: {
+        readonly cancel: "Cancel";
+        readonly next: "Next";
+    };
+    readonly searcher: {
+        readonly clear_tip: "Clear";
+        readonly empty: "No items to show";
+        readonly without_selected: "No selected items";
+    };
+    readonly alerts: {
+        readonly success_title: "Operation successful";
+        readonly error_title: "An error occurred";
+        readonly delete_title: "Action confirmation";
+        readonly delete_confirm: "Yes, delete";
+        readonly warning_title: "Alert!";
+    };
+    readonly voice: {
+        readonly browser_incompatibility_title: "Browser incompatibility";
+        readonly browser_incompatibility_message: "This browser does not support this feature.";
+        readonly voice_error: "Error while starting voice dictation";
+    };
+    readonly form_builder: {
+        readonly block_title: "Title";
+        readonly add_new_field: "Add new field";
+        readonly block_subtitle: "Subtitle";
+        readonly add_block: "Add block";
+        readonly delete_block: "Delete block";
+        readonly preview_form: "Preview";
+        readonly submit_form: "Submit";
+        readonly select_field_to_edit: "Select a field to edit its properties";
+        readonly no_fields: "Add fields to your form";
+        readonly base: {
+            readonly name: "Key";
+            readonly required: "Required";
+            readonly icon: "Icon";
+            readonly label: "Label";
+            readonly tip: "Hint";
+            readonly tip_tip: "Shown below";
+            readonly new_line: "New line";
+            readonly col_span: "Column span";
+            readonly col_span_tip: "How many columns the field occupies";
+        };
+        readonly extra: {
+            readonly iconColor: "Icon color";
+            readonly tooltip: "Tooltip";
+            readonly internalIcon: "Internal icon";
+            readonly internalIconColor: "Internal icon color";
+            readonly internalColorScale: "Internal color scale";
+            readonly internalColorScale_tip: "Values for rendering the scale";
+            readonly internalColorScaleOrder: "Color scale order";
+            readonly internalColorScaleOrder_tip: "Ascending or descending";
+            readonly placeholder: "Placeholder";
+            readonly placeholder_tip: "Default field text";
+            readonly minLength: "Minimum length";
+            readonly minLength_tip: "Least allowed chars";
+            readonly maxLength: "Maximum length";
+            readonly maxLength_tip: "Most allowed chars";
+            readonly showCounter: "Show counter";
+            readonly showCounter_tip: "Show typed character count";
+            readonly voiceToTextEnabled: "Enable voice to text";
+            readonly voiceToTextEnabled_tip: "Enable speech input";
+            readonly textareaResize: "Autosize textarea";
+            readonly textareaResize_tip: "Grow or shrink by content";
+            readonly resizeMinRows: "Minimum rows";
+            readonly resizeMinRows_tip: "Initial minimum rows";
+            readonly resizeMaxRows: "Maximum rows";
+            readonly resizeMaxRows_tip: "Initial maximum rows";
+            readonly min: "Minimum";
+            readonly min_tip: "Smallest accepted value";
+            readonly max: "Maximum";
+            readonly max_tip: "Largest accepted value";
+            readonly step: "Step";
+            readonly step_tip: "Increment between values";
+            readonly sliderInterval: "Slider interval";
+            readonly sliderInterval_tip: "Spacing between marks";
+            readonly sliderMarks: "Slider marks";
+            readonly sliderMarks_tip: "Number of scale marks";
+            readonly monthMode: "Month mode";
+            readonly monthMode_tip: "Select a month date";
+            readonly monthDay: "Month day";
+            readonly monthDay_tip: "Pick first or last day";
+            readonly minDate: "Minimum date";
+            readonly minDate_tip: "Earliest allowed date";
+            readonly maxDate: "Maximum date";
+            readonly maxDate_tip: "Latest allowed date";
+            readonly timeInterval: "Time interval";
+            readonly timeInterval_tip: "Minute step";
+            readonly fileTypes: "File types";
+            readonly fileTypes_tip: "Comma-separated extensions";
+            readonly poolEnabledListView: "Enable list view";
+            readonly poolEnabledListView_tip: "Show pool in list mode";
+            readonly poolTitle: "List title";
+            readonly poolTitle_tip: "Title for list header";
+            readonly options: "Options";
+            readonly options_tip: "JSON list: [{id:1,text:\"A\"}]";
+            readonly multyEnabled: "Multiple";
+            readonly multyEnabled_tip: "Allow multi-select";
+            readonly searchFn: "Search function";
+            readonly searchFn_tip: "Function called to search";
+            readonly searchDisplayFn: "Display function";
+            readonly searchDisplayFn_tip: "Function to render option text";
+            readonly searchIsEnabledFn: "Enabled function";
+            readonly searchIsEnabledFn_tip: "Function to enable or disable option";
+            readonly pattern: "Pattern";
+            readonly pattern_tip: "Regular expression in text";
+            readonly iaValidation: "IA Validation";
+            readonly iaValidationPrompt: "IA Validation Prompt";
+            readonly searchApi: "Search API";
+            readonly searchApi_tip: "URL to fetch search options";
+            readonly selectNullable_tip: "Allows selecting an empty option";
+            readonly selectSearchEnabled_tip: "Enables search among options";
+            readonly selectNullable: "Allow empty option";
+            readonly selectSearchEnabled: "Enable search";
+        };
+        readonly options_editor: {
+            readonly title: "Options";
+            readonly code_label: "Code";
+            readonly name_label: "Label";
+            readonly code_placeholder: "ID";
+            readonly display_name_placeholder: "Display name";
+            readonly add_option: "Add option";
+        };
+        readonly field_editor: {
+            readonly dependency_title: "Dependency";
+            readonly dependency_description: "This field is shown only if the rule is met:";
+            readonly add_relation: "Add relation";
+            readonly remove_relation: "Remove relation";
+            readonly basic: "Basic";
+            readonly parent: "Parent";
+            readonly operator: "Operator";
+            readonly value: "Value";
+            readonly expected_value: "Expected value";
+            readonly style: "Style";
+            readonly advanced: "Advanced";
+            readonly duplicate: "Duplicate";
+            readonly delete: "Delete";
+            readonly show_advanced: "Show advanced";
+            readonly hide_advanced: "Hide advanced";
+        };
+        readonly validation: {
+            readonly duplicate_identifier: "The identifier \"{{identifier}}\" is used more than once.";
+            readonly duplicate_identifier_title: "Validation error";
+        };
+    };
+    readonly validation: {
+        readonly invalid: "{{field}} is invalid.";
+        readonly required: "{{field}} is required.";
+        readonly min: "{{field}} must be greater than or equal to {{min}}.";
+        readonly max: "{{field}} must be less than or equal to {{max}}.";
+        readonly minlength: "{{field}} must have at least {{requiredLength}} characters.";
+        readonly maxlength: "{{field}} cannot exceed {{requiredLength}} characters.";
+        readonly pattern: "{{field}} has an invalid format.";
+    };
+    readonly clipboard: {
+        readonly copy_error: "Could not copy:";
+    };
+};