wuic-framework-lib 0.0.1

package/lib/component/code-editor/code-editor.component.d.ts

@@ -0,0 +1,86 @@
+import { HttpClient } from '@angular/common/http';
+import { OnInit, AfterViewInit, OnDestroy } from '@angular/core';
+import { MonacoEditorComponent, MonacoEditorLoaderService } from '@materia-ui/ngx-monaco-editor';
+import { BehaviorSubject } from 'rxjs';
+import { SqlProvider } from './sql-parser';
+import { MetadatiColonna } from '../../class/metadati_colonna';
+import { EditorOptions } from './editor-options';
+import { MetaInfo } from '../../class/metaInfo';
+import { WtoolboxService } from '../../service/wtoolbox.service';
+import { MetadataProviderService } from '../../service/metadata-provider.service';
+import { UserInfoService } from '../../service/user-info.service';
+import { TSProvider } from './ts-parser';
+import { DataProviderService } from '../../service/data-provider.service';
+import { HtmlProvider } from './html-parser';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class CodeEditorComponent implements OnInit, AfterViewInit, OnDestroy {
+    private monacoLoaderService;
+    private http;
+    private metaSrv;
+    private userInfo;
+    private dataSrv;
+    private wtoolbox;
+    private sanitizer;
+    style: string;
+    contextMenuAnchor: any;
+    field: MetadatiColonna;
+    record?: {
+        [key: string]: BehaviorSubject<any>;
+    };
+    metaInfo: MetaInfo;
+    editorRef: MonacoEditorComponent | undefined;
+    editor: monaco.editor.IStandaloneCodeEditor | undefined;
+    ctxs: any;
+    editorOptions: EditorOptions;
+    editorModelValue: string;
+    sampleCode: string;
+    fullscreen: boolean;
+    render: boolean;
+    treeNodes: any[];
+    primeTreeNodes: any[];
+    sqlObjView: boolean;
+    sqlProvider: SqlProvider | undefined;
+    errors: {
+        Message: string;
+    }[];
+    codeContext: string;
+    tsProvider: TSProvider;
+    htmlProvider: HtmlProvider | undefined;
+    showHtmlPreview: boolean;
+    autoFormatHtml: boolean;
+    sanitizedHtmlPreview: SafeHtml | string;
+    private htmlFormatHandle;
+    private skipNextAutoFormat;
+    private layoutRaf;
+    private scrollHosts;
+    private readonly onHostScroll;
+    private recordValueSub;
+    private syncingFromRecord;
+    constructor(monacoLoaderService: MonacoEditorLoaderService, http: HttpClient, metaSrv: MetadataProviderService, userInfo: UserInfoService, dataSrv: DataProviderService, wtoolbox: WtoolboxService, sanitizer: DomSanitizer);
+    setFullScreen($event: any, ctx: any): void;
+    toggleSqlObjView($event: any, ctx: any): void;
+    onContentChange($event: any): void;
+    onTreeNodeDragStart(event: DragEvent, dataItem: any): void;
+    onTreeNodeDragEnd(event: DragEvent, dataItem: any): void;
+    testSql($event: any, ctx: any): Promise<void>;
+    suggest($event: any, ctx: any): Promise<void>;
+    onEditorModelChange(value: string): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private scheduleEditorLayout;
+    private getScrollableAncestors;
+    private bindRecordValue;
+    get isHtmlEditor(): boolean;
+    toggleHtmlPreview($event: any): void;
+    formatHtmlNow($event?: any): void;
+    private scheduleAutoFormatHtml;
+    private refreshHtmlPreview;
+    private sanitizeHtmlForPreview;
+    private transformAngularTemplateForPreview;
+    private extractMetaColumnCaption;
+    private mapToPrimeTreeNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CodeEditorComponent, "wuic-code-editor", never, { "field": { "alias": "field"; "required": false; }; "record": { "alias": "record"; "required": false; }; "metaInfo": { "alias": "metaInfo"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/component/code-editor/editor-options.d.ts

@@ -0,0 +1,12 @@
+export declare class EditorOptions {
+    theme: string;
+    language: 'json' | 'typescript' | 'sql' | 'csharp' | 'html';
+    contextMenuItems: any[];
+    model?: any;
+    onInit?: any;
+    onNodeClick?: any;
+    onNodeDragStart?: any;
+    onNodeDragEnd?: any;
+    onDropIntoEditor?: any;
+    constructor(theme: string, language: 'json' | 'typescript' | 'sql' | 'csharp' | 'html');
+}

package/lib/component/code-editor/html-parser.d.ts

@@ -0,0 +1,27 @@
+import { EditorOptions } from './editor-options';
+import { WuicComponentBindings } from './wuic-component-bindings';
+export declare class HtmlProvider {
+    private editorOptions;
+    private componentSelectors;
+    private componentBindings;
+    private editor;
+    private validateHandle;
+    private readonly markerOwner;
+    private completionProviderDisposable;
+    private formatterDisposable;
+    private readonly htmlSnippets;
+    constructor(editorOptions: EditorOptions, componentSelectors?: string[], componentBindings?: Record<string, WuicComponentBindings>);
+    registerHtmlProvider(): void;
+    setEditor(editor: monaco.editor.IStandaloneCodeEditor): void;
+    dispose(): void;
+    private scheduleValidate;
+    private validateNow;
+    private buildStrictMarkers;
+    private buildTagBalanceMarkers;
+    private buildAngularSyntaxMarkers;
+    private registerCompletionProvider;
+    private getOpenTagContext;
+    private buildAngularBindingSuggestions;
+    private registerDocumentFormatter;
+    private formatHtml;
+}

package/lib/component/code-editor/sql-model.d.ts

@@ -0,0 +1,87 @@
+export declare class SqlModel {
+    database: string;
+    isDefault: boolean;
+    schema: string;
+    tables: SqlTable[];
+    types: SqlTable[];
+    functions: SqlFunctionStored[];
+    storeds: SqlFunctionStored[];
+}
+export declare class SqlFunctionStored {
+    schema: string;
+    name: string;
+    type: string;
+    parameters: SqlParameter[];
+}
+export declare class SqlParameter {
+    name: string;
+    type: string;
+    isOutput: boolean;
+    isReadOnly: boolean;
+    order: number;
+    size: string;
+}
+export declare class SqlTable {
+    schema: string;
+    table: string;
+    alias: string;
+    schemaObj: SqlModel;
+    columns: SqlColumn[];
+}
+export declare class SqlRelation {
+    schemaPK: string;
+    tablePK: string;
+    columnPK: string;
+    schemaFK: string;
+    tableFK: string;
+    columnFK: string;
+}
+export declare class SqlColumn {
+    schema: string;
+    table: string;
+    tableAlias: string;
+    column: string;
+    type: string;
+    isNullable: boolean;
+    columnDescription: string;
+    isPkey: boolean;
+    isIdentity: boolean;
+    order: number;
+    childRelations: SqlRelation[];
+    parentRelation: SqlRelation;
+}
+export type Stack<T> = {
+    text: T;
+    sqlDatabase?: string;
+    sqlModel?: SqlModel;
+    sqlTable?: SqlTable;
+    parentTable?: SqlTable;
+    sqlColumn?: SqlColumn;
+    sqlRelation?: SqlRelation;
+    sqlParameter?: SqlParameter;
+    sqlFunction?: SqlFunctionStored;
+    items?: Stack<T>[] | null;
+};
+export declare class Statement {
+    statement: string;
+    index: number;
+    words: {
+        token: string;
+        tokenIndx: number;
+    }[];
+    sqlModels: SqlModel[];
+    sqlTables: {
+        table: SqlTable;
+        usedAlias: string;
+    }[];
+    sqlColumns: {
+        column: SqlColumn;
+        usedAlias: string;
+    }[];
+    sqlAliases: any[];
+    subStatements: {
+        key: string;
+        statement: Statement;
+    }[];
+    constructor(statement: string, index: number);
+}

package/lib/component/code-editor/sql-parser.d.ts

@@ -0,0 +1,157 @@
+import { SqlTable, SqlModel, Stack, Statement } from "./sql-model";
+import { HttpClient } from '@angular/common/http';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event';
+export declare class SqlProvider {
+    private http;
+    currents: CurrentProviderDataContext;
+    previousStatements: string[];
+    schemas: SqlModel[];
+    editorOptions: any;
+    userDefTypes: SqlTable[];
+    treeNodes: Stack<string>[];
+    private editor;
+    constructor(http: HttpClient, editorOptions: any);
+    setEditor(editor: monaco.editor.IStandaloneCodeEditor): void;
+    registerSqlProvider(treeNodes: Stack<string>[]): Promise<void>;
+    getAutocompleteSuggestions(originalText: string, position: monaco.Position, lastWord?: monaco.editor.IWordAtPosition, scaffoldedOnly?: boolean): monaco.languages.CompletionList;
+    private createTreeMenu;
+    testSql(): Promise<any[]>;
+    sanitize(str: string): string;
+    private normalizeStatement;
+    removeNestedStatements(statement: string, nestedStatements: RegExpMatchArray[], currentIndx?: number): string;
+    getNestedStatements(statement: string): RegExpMatchArray[];
+    getNestedStatement(currentStmnt: Statement, matchingKeyWord: string, found: {
+        key: string;
+        statement: Statement;
+        parentStatement: Statement;
+        desiredLevel: number;
+        desiredIndex: number;
+    }, level?: number, parentIndex?: number): void;
+    processText(text: any, position: monaco.Position): {
+        char: string;
+        parentIndx: any;
+        lineNumber: number;
+        column: number;
+        statementIndex: number;
+        nestingIndex: number;
+        nestingLevel: number;
+    }[][];
+    getContextInfo(originalText: string, position: monaco.Position): ContextInfo;
+    getContextInfoOld(originalText: string, position: monaco.Position): ContextInfo;
+    getAutocompleteContext(contextInfo: ContextInfo): autocompleteContext;
+    evaluateAutocompleteContext(contextInfo: ContextInfo, statement: Statement, skipAs?: boolean, defaultAutoCtx?: autocompleteContext, contextDelegate?: (statement: Statement, contextInfo: ContextInfo) => autocompleteContext): autocompleteContext;
+    private matchesDefaultContextPrefix;
+    evaluateAutocompleteWhereContext(currents: CurrentProviderDataContext, currentStatementWords: string[], whereSubStatemnt: Statement): autocompleteContext.comparisonOperator | autocompleteContext.columnWhere;
+    private clearCurrents;
+    parseStatements(): void;
+    private parseStatementRecursive;
+    populateGlobalTables(statement: any, found: any): boolean;
+    private populateDeclarations;
+    private populateCurrentColumns;
+    populateAlias(element: string, stmntIndx: number, found: boolean, statementObj: Statement, subStatement: Statement): boolean;
+    private populateCurrentSchemaTables;
+    getSuggestionsByContext(context: autocompleteContext, range: monaco.IRange, originalText: string, contextInfo: ContextInfo, scaffoldedOnly?: boolean): monaco.languages.CompletionList;
+    private getModelDatabaseName;
+    private getModelSchemaName;
+    private getColumnDatabaseName;
+    private getDefaultDatabaseName;
+    private parseTblRelations;
+    getTableByAlias(alias: string, statement: Statement): SqlTable;
+}
+export declare class ContextMenuInteractionEmitter extends Emitter {
+    private editor;
+    private sqlProvider;
+    constructor(_contributions: any, deliveryQueue: any, editor: any, sqlProvider: any);
+    fire(event: {
+        event: {
+            leftButton: boolean;
+            middleButton: boolean;
+            rightButton: boolean;
+            buttons: number;
+            detail: number;
+            ctrlKey: boolean;
+            shiftKey: boolean;
+            altKey: boolean;
+            posx: number;
+            posy: number;
+            editorPos: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            };
+            relativePos: {
+                x: number;
+                y: number;
+            };
+            preventDefault: () => void;
+            stopPropagation: () => void;
+        };
+        target: {
+            element: HTMLElement;
+            position: monaco.Position;
+            range: monaco.IRange;
+            mouseColumn: number;
+            type: number;
+        };
+    }): void;
+}
+declare class ContextInfo {
+    words: {
+        word: string;
+        statementIndx: number;
+    }[];
+    nonNestedWords: {
+        word: string;
+        statementIndx: number;
+    }[];
+    currentStmntIndex: number;
+    nestedStatementIndex: number;
+    nestedStatementLevel?: number;
+    currentStatement?: Statement;
+    currentSubStatement?: {
+        key: string;
+        statement: Statement;
+    };
+    position: monaco.Position;
+    absolutePosition?: number;
+    adjacentChars: string;
+}
+declare class CurrentProviderDataContext {
+    declarations: {
+        paramName: string;
+        paramtype: string;
+        usertype?: SqlTable;
+    }[];
+    globalTables: SqlTable[];
+    statements: Statement[];
+}
+declare enum autocompleteContext {
+    statement = 0,
+    statementSelect = 1,
+    statementFrom = 2,
+    statementWhere = 3,
+    statementWhereJoin = 4,
+    columnWhereRestricted = 5,
+    columnWhereSkipAlias = 6,
+    statementOn = 7,
+    statementOnRelation = 8,
+    comparisonOperator = 9,
+    declaration = 10,
+    sqlType = 11,
+    schema = 12,
+    schemaJoin = 13,
+    table = 14,
+    tableNoAs = 15,
+    tableJoin = 16,
+    columnSelect = 17,
+    columnWhere = 18,
+    columnOrder = 19,
+    columnGroupBy = 20,
+    variable = 21,
+    columnWhereAndVariables = 22,
+    statementSet = 23,
+    assignmentOperator = 24,
+    statementValues = 25
+}
+export {};

package/lib/component/code-editor/ts-parser.d.ts

@@ -0,0 +1,93 @@
+import { SqlTable, SqlModel, Stack } from "./sql-model";
+import { HttpClient } from '@angular/common/http';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event';
+import { EditorOptions } from "./editor-options";
+import { MetadatiColonna } from "../../class/metadati_colonna";
+import { MetadataProviderService } from "../../service/metadata-provider.service";
+export declare class TSProvider {
+    private http;
+    previousStatements: string[];
+    schemas: SqlModel[];
+    editorOptions: EditorOptions;
+    userDefTypes: SqlTable[];
+    treeNodes: Stack<string>[];
+    private editor;
+    contextMenuEvent: {
+        event: {
+            leftButton: boolean;
+            middleButton: boolean;
+            rightButton: boolean;
+            buttons: number;
+            detail: number;
+            ctrlKey: boolean;
+            shiftKey: boolean;
+            altKey: boolean;
+            posx: number;
+            posy: number;
+            editorPos: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            };
+            relativePos: {
+                x: number;
+                y: number;
+            };
+            preventDefault: () => void;
+            stopPropagation: () => void;
+        };
+        target: {
+            element: HTMLElement;
+            position: monaco.Position;
+            range: monaco.IRange;
+            mouseColumn: number;
+            type: number;
+        };
+    };
+    snippets: {
+        [key: string]: string;
+    };
+    constructor(http: HttpClient, editorOptions: EditorOptions);
+    snippeter(snippetKey: any, snippetValue: any): void;
+    setEditor(editor: monaco.editor.IStandaloneCodeEditor): void;
+    registerTSProvider(formFieldOptions: any, field: MetadatiColonna, codeContext: string, record: any, metaSrv: MetadataProviderService, userInfo: any): Promise<void>;
+}
+export declare class ContextMenuInteractionEmitter extends Emitter {
+    private editor;
+    private tsProvider;
+    constructor(_contributions: any, deliveryQueue: any, editor: any, tsProvider: any);
+    fire(event: {
+        event: {
+            leftButton: boolean;
+            middleButton: boolean;
+            rightButton: boolean;
+            buttons: number;
+            detail: number;
+            ctrlKey: boolean;
+            shiftKey: boolean;
+            altKey: boolean;
+            posx: number;
+            posy: number;
+            editorPos: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            };
+            relativePos: {
+                x: number;
+                y: number;
+            };
+            preventDefault: () => void;
+            stopPropagation: () => void;
+        };
+        target: {
+            element: HTMLElement;
+            position: monaco.Position;
+            range: monaco.IRange;
+            mouseColumn: number;
+            type: number;
+        };
+    }): void;
+}

package/lib/component/code-editor/wuic-component-bindings.d.ts

@@ -0,0 +1,7 @@
+export type WuicComponentBindings = {
+    inputs?: string[];
+    outputs?: string[];
+    twoWay?: string[];
+};
+export declare const WUIC_COMMON_INPUTS: string[];
+export declare const WUIC_COMPONENT_BINDINGS: Record<string, WuicComponentBindings>;

package/lib/component/code-editor/wuic-component-selectors.d.ts

@@ -0,0 +1 @@
+export declare const WUIC_COMPONENT_SELECTORS: string[];

package/lib/component/css-sheet-editor/css-sheet-editor.component.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+type CssStyleRow = {
+    Key: string;
+    Value: string;
+};
+type CssClassRow = {
+    SelectorString: string;
+    ClassNames: string[];
+    Styles: CssStyleRow[];
+    Media?: string;
+};
+type CssSheetRow = {
+    SheetPath: string;
+    classes: CssClassRow[];
+};
+type StyleProp = {
+    key: string;
+    type: string;
+    values?: string[];
+};
+export declare class CssSheetEditorComponent implements OnChanges {
+    visible: boolean;
+    visibleChange: EventEmitter<boolean>;
+    sheets: CssSheetRow[];
+    selectedSheetPath: string;
+    styleProps: StyleProp[];
+    assetsFolder: string;
+    applyEditor: EventEmitter<{
+        sheets: CssSheetRow[];
+        selectedSheetPath: string;
+    }>;
+    draftSheets: CssSheetRow[];
+    selectedSheetPathDraft: string;
+    selectedClassSelector: string;
+    pendingStyleKey: string;
+    pendingStyleValue: string;
+    newSheetName: string;
+    newClassName: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    close(): void;
+    addSheet(): void;
+    removeSelectedSheet(): void;
+    addClassToSelectedSheet(): void;
+    removeSelectedClass(): void;
+    addStyleToSelectedClass(): void;
+    removeStyle(index: number): void;
+    onStyleKeyChanged(style: CssStyleRow): void;
+    onStyleValueChanged(): void;
+    onPendingStyleKeyChanged(): void;
+    getPropertyValues(propKey: string): string[];
+    isPropertyDictionary(propKey: string): boolean;
+    isPropertyColor(propKey: string): boolean;
+    colorPickerValue(value: string): string;
+    onPendingColorChanged(value: string): void;
+    onStyleColorChanged(style: CssStyleRow, value: string): void;
+    onSelectedSheetChanged(): void;
+    onSelectedClassChanged(): void;
+    private syncDraft;
+    private cloneSheets;
+    private defaultValueForProperty;
+    private normalizePath;
+    private buildAssetSheetPath;
+    private emitChanges;
+    private resetPendingStyle;
+    get currentSheet(): CssSheetRow | null;
+    get currentClass(): CssClassRow | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CssSheetEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CssSheetEditorComponent, "wuic-css-sheet-editor", never, { "visible": { "alias": "visible"; "required": false; }; "sheets": { "alias": "sheets"; "required": false; }; "selectedSheetPath": { "alias": "selectedSheetPath"; "required": false; }; "styleProps": { "alias": "styleProps"; "required": false; }; "assetsFolder": { "alias": "assetsFolder"; "required": false; }; }, { "visibleChange": "visibleChange"; "applyEditor": "applyEditor"; }, never, never, true, never>;
+}
+export {};

package/lib/component/dashboard/dashboard.component.d.ts

@@ -0,0 +1,12 @@
+import { AfterViewInit } from '@angular/core';
+import { DynamicDashboardTemplateComponent } from '../dynamic-dashboard-template/dynamic-dashboard-template.component';
+import * as i0 from "@angular/core";
+export declare class DashboardComponent implements AfterViewInit {
+    dashboardElements: any[];
+    constructor();
+    getComponent(dashboardElement: any): typeof DynamicDashboardTemplateComponent;
+    ngAfterViewInit(): void;
+    onResizing(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardComponent, "wuic-dashboard", never, { "dashboardElements": { "alias": "dashboardElements"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/component/data-action-button/data-action-button.component.d.ts

@@ -0,0 +1,45 @@
+import { AfterViewInit, ChangeDetectorRef } from '@angular/core';
+import { MetaInfo } from '../../class/metaInfo';
+import { SplitButton } from 'primeng/splitbutton';
+import { TranslationManagerService } from '../../service/translation-manager.service';
+import { DataSourceComponent } from '../data-source/data-source.component';
+import { ConfirmationService, MenuItem, MessageService } from 'primeng/api';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DataActionButtonComponent implements AfterViewInit {
+    private trslSrv;
+    private cd;
+    private messageService;
+    private confirmationService;
+    data: any;
+    metaInfo: MetaInfo;
+    datasource: BehaviorSubject<DataSourceComponent>;
+    filter?: () => void;
+    simplified: boolean;
+    btn: SplitButton;
+    items: MenuItem[];
+    selectedValue: any;
+    pkName: string;
+    inlineItems: any[];
+    constructor(trslSrv: TranslationManagerService, cd: ChangeDetectorRef, messageService: MessageService, confirmationService: ConfirmationService);
+    test($event: any): void;
+    ngAfterViewInit(): void;
+    select(item: any): void;
+    private appendMetadataButtonItems;
+    private getButtonActionRecord;
+    private isMetadataButtonEnabled;
+    private executeMetadataButton;
+    edit(): void;
+    delete(): Promise<void>;
+    detail(): void;
+    clone(): void;
+    save(): Promise<void>;
+    cancelEdit(): Promise<void>;
+    onClick($event: any): void;
+    onMenuHide($event: any): void;
+    onMenuShow($event: any): void;
+    onDropdownClick($event: any): void;
+    fix($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataActionButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataActionButtonComponent, "wuic-data-action-button", never, { "data": { "alias": "data"; "required": false; }; "metaInfo": { "alias": "metaInfo"; "required": false; }; "datasource": { "alias": "datasource"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "simplified": { "alias": "simplified"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/component/data-repeater/data-repeater.component.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { DataSourceComponent } from '../data-source/data-source.component';
+import { BehaviorSubject } from 'rxjs';
+import { MetadatiColonna } from '../../class/metadati_colonna';
+import { Table } from 'primeng/table';
+import * as i0 from "@angular/core";
+export declare class DataRepeaterComponent implements OnInit {
+    datasource: BehaviorSubject<DataSourceComponent>;
+    hardcodedDatasource: DataSourceComponent;
+    action: BehaviorSubject<string>;
+    hardcodedAction: string;
+    field: MetadatiColonna;
+    record: any;
+    rowCustomSelect: (rowData: any, $event: any, dt: Table) => void;
+    templateReady: EventEmitter<string>;
+    archetype: string;
+    archetypes: {
+        [key: string]: {
+            markup: string;
+            component: any;
+            designerOptions?: any;
+        };
+    };
+    repeaterTemplate: any;
+    constructor();
+    private normalizeArchetypeAction;
+    private resolveArchetype;
+    private renderArchetype;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataRepeaterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataRepeaterComponent, "wuic-data-repeater", never, { "datasource": { "alias": "datasource"; "required": false; }; "hardcodedDatasource": { "alias": "hardcodedDatasource"; "required": false; }; "action": { "alias": "action"; "required": false; }; "hardcodedAction": { "alias": "hardcodedAction"; "required": false; }; "field": { "alias": "field"; "required": false; }; "record": { "alias": "record"; "required": false; }; "rowCustomSelect": { "alias": "rowCustomSelect"; "required": false; }; }, { "templateReady": "templateReady"; }, never, never, true, never>;
+}