@en-solutions/tgm-client-sdk 1.6.21

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@en-solutions/tgm-client-sdk" />
+export * from './public-api';

package/lib/components/database-manager/database-manager/database-manager.component.d.ts

@@ -0,0 +1,70 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges, TemplateRef } from '@angular/core';
+import { DatabaseManagerConfig, EditorTab, EntityRegistryEntry, QueryResult } from '../types/database-manager.types';
+import { EntitySchemaService } from '../services/entity-schema.service';
+import { QueryExecutorService } from '../services/query-executor.service';
+import * as i0 from "@angular/core";
+export declare class DatabaseManagerComponent implements OnInit, OnChanges, OnDestroy {
+    private entitySchema;
+    private queryExecutor;
+    config: DatabaseManagerConfig;
+    containerClass: string;
+    sidebarClass: string;
+    mainClass: string;
+    title: string;
+    noResultsMessage: string;
+    loadingMessage: string;
+    headerTemplate?: TemplateRef<void>;
+    sidebarHeaderTemplate?: TemplateRef<void>;
+    tabTemplate?: TemplateRef<{
+        $implicit: EditorTab;
+    }>;
+    emptyTemplate?: TemplateRef<void>;
+    entitySelected: EventEmitter<EntityRegistryEntry>;
+    queryExecuted: EventEmitter<QueryResult>;
+    recordSelected: EventEmitter<{
+        entity: string;
+        record: any;
+    }>;
+    recordCreated: EventEmitter<any>;
+    recordUpdated: EventEmitter<any>;
+    recordDeleted: EventEmitter<any>;
+    error: EventEmitter<any>;
+    selectedEntity?: EntityRegistryEntry;
+    tabs: EditorTab[];
+    activeTabId?: string;
+    queryText: string;
+    executing: boolean;
+    activeResult?: QueryResult;
+    selectedRecord?: any;
+    recordMode: 'view' | 'edit' | 'create';
+    showRecordDetail: boolean;
+    private tabCounter;
+    private subscription?;
+    constructor(entitySchema: EntitySchemaService, queryExecutor: QueryExecutorService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    get activeTab(): EditorTab | undefined;
+    addQueryTab(): void;
+    addTableDataTab(entity: EntityRegistryEntry): void;
+    addTableStructureTab(entity: EntityRegistryEntry): void;
+    selectTab(tab: EditorTab): void;
+    closeTab(tab: EditorTab, event: Event): void;
+    onEntitySelected(entity: EntityRegistryEntry): void;
+    onEntityDoubleClick(entity: EntityRegistryEntry): void;
+    onQueryChange(text: string): void;
+    onExecute(): void;
+    onExecuteFromEditor(text: string): void;
+    onFormat(): void;
+    onClear(): void;
+    onRecordClick(record: any): void;
+    onRecordDoubleClick(record: any): void;
+    closeRecordDetail(): void;
+    onRecordSave(data: any): void;
+    onRecordDelete(record: any): void;
+    getEntityForTab(tab: EditorTab): EntityRegistryEntry | undefined;
+    trackByTabId(_index: number, tab: EditorTab): string;
+    private executeQuery;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatabaseManagerComponent, "tgm-database-manager", never, { "config": { "alias": "config"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; "sidebarClass": { "alias": "sidebarClass"; "required": false; }; "mainClass": { "alias": "mainClass"; "required": false; }; "title": { "alias": "title"; "required": false; }; "noResultsMessage": { "alias": "noResultsMessage"; "required": false; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "sidebarHeaderTemplate": { "alias": "sidebarHeaderTemplate"; "required": false; }; "tabTemplate": { "alias": "tabTemplate"; "required": false; }; "emptyTemplate": { "alias": "emptyTemplate"; "required": false; }; }, { "entitySelected": "entitySelected"; "queryExecuted": "queryExecuted"; "recordSelected": "recordSelected"; "recordCreated": "recordCreated"; "recordUpdated": "recordUpdated"; "recordDeleted": "recordDeleted"; "error": "error"; }, never, never, true, never>;
+}

package/lib/components/database-manager/database-manager.module.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./database-manager/database-manager.component";
+import * as i3 from "./object-browser/object-browser.component";
+import * as i4 from "./query-editor/query-editor.component";
+import * as i5 from "./query-toolbar/query-toolbar.component";
+import * as i6 from "./results-grid/results-grid.component";
+import * as i7 from "./table-structure/table-structure.component";
+import * as i8 from "./table-data-viewer/table-data-viewer.component";
+import * as i9 from "./record-detail/record-detail.component";
+export declare class DatabaseManagerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DatabaseManagerModule, never, [typeof i1.CommonModule, typeof i2.DatabaseManagerComponent, typeof i3.ObjectBrowserComponent, typeof i4.QueryEditorComponent, typeof i5.QueryToolbarComponent, typeof i6.ResultsGridComponent, typeof i7.TableStructureComponent, typeof i8.TableDataViewerComponent, typeof i9.RecordDetailComponent], [typeof i2.DatabaseManagerComponent, typeof i3.ObjectBrowserComponent, typeof i4.QueryEditorComponent, typeof i5.QueryToolbarComponent, typeof i6.ResultsGridComponent, typeof i7.TableStructureComponent, typeof i8.TableDataViewerComponent, typeof i9.RecordDetailComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DatabaseManagerModule>;
+}

package/lib/components/database-manager/object-browser/object-browser.component.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, OnChanges, SimpleChanges, TemplateRef } from '@angular/core';
+import { EntityRegistryEntry, EntityModuleGroup, DatabaseManagerConfig } from '../types/database-manager.types';
+import { EntitySchemaService } from '../services/entity-schema.service';
+import * as i0 from "@angular/core";
+export declare class ObjectBrowserComponent implements OnChanges {
+    private entitySchema;
+    config?: DatabaseManagerConfig;
+    selectedEntity?: EntityRegistryEntry;
+    searchPlaceholder: string;
+    groupLabels?: Record<string, string>;
+    entityTemplate?: TemplateRef<{
+        $implicit: EntityRegistryEntry;
+    }>;
+    groupTemplate?: TemplateRef<{
+        $implicit: EntityModuleGroup;
+    }>;
+    selectEntity: EventEmitter<EntityRegistryEntry>;
+    doubleClickEntity: EventEmitter<EntityRegistryEntry>;
+    searchTerm: string;
+    groups: EntityModuleGroup[];
+    filteredGroups: EntityModuleGroup[];
+    constructor(entitySchema: EntitySchemaService);
+    ngOnChanges(changes: SimpleChanges): void;
+    onSearch(): void;
+    toggleGroup(group: EntityModuleGroup): void;
+    onSelectEntity(entity: EntityRegistryEntry): void;
+    onDoubleClick(entity: EntityRegistryEntry): void;
+    isSelected(entity: EntityRegistryEntry): boolean;
+    trackByCode(_index: number, group: EntityModuleGroup): string;
+    trackByKey(_index: number, entity: EntityRegistryEntry): string;
+    private loadGroups;
+    private filterGroups;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectBrowserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectBrowserComponent, "tgm-object-browser", never, { "config": { "alias": "config"; "required": false; }; "selectedEntity": { "alias": "selectedEntity"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "groupLabels": { "alias": "groupLabels"; "required": false; }; "entityTemplate": { "alias": "entityTemplate"; "required": false; }; "groupTemplate": { "alias": "groupTemplate"; "required": false; }; }, { "selectEntity": "selectEntity"; "doubleClickEntity": "doubleClickEntity"; }, never, never, true, never>;
+}

package/lib/components/database-manager/query-editor/query-editor.component.d.ts

@@ -0,0 +1,31 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { EntityRegistryEntry } from '../types/database-manager.types';
+import * as i0 from "@angular/core";
+export declare class QueryEditorComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
+    value: string;
+    entitySchema?: EntityRegistryEntry;
+    enableMonaco: boolean;
+    monacoOptions?: any;
+    placeholder: string;
+    editorClass: string;
+    valueChange: EventEmitter<string>;
+    execute: EventEmitter<string>;
+    monacoContainer?: ElementRef;
+    textareaEl?: ElementRef;
+    monacoAvailable: boolean;
+    private monacoEditor;
+    private completionDisposable;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onMonacoInit(): void;
+    onTextareaInput(event: Event): void;
+    onTextareaKeydown(event: KeyboardEvent): void;
+    /**
+     * Called after view init if Monaco is available.
+     */
+    ngAfterViewInit(): void;
+    private registerCompletionProvider;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueryEditorComponent, "tgm-query-editor", never, { "value": { "alias": "value"; "required": false; }; "entitySchema": { "alias": "entitySchema"; "required": false; }; "enableMonaco": { "alias": "enableMonaco"; "required": false; }; "monacoOptions": { "alias": "monacoOptions"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "editorClass": { "alias": "editorClass"; "required": false; }; }, { "valueChange": "valueChange"; "execute": "execute"; }, never, never, true, never>;
+}

package/lib/components/database-manager/query-toolbar/query-toolbar.component.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class QueryToolbarComponent {
+    executing: boolean;
+    disabled: boolean;
+    showHistory: boolean;
+    showFormat: boolean;
+    executeLabel: string;
+    formatLabel: string;
+    clearLabel: string;
+    historyLabel: string;
+    toolbarTemplate?: TemplateRef<void>;
+    execute: EventEmitter<void>;
+    format: EventEmitter<void>;
+    clear: EventEmitter<void>;
+    toggleHistory: EventEmitter<void>;
+    onExecute(): void;
+    onFormat(): void;
+    onClear(): void;
+    onToggleHistory(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueryToolbarComponent, "tgm-query-toolbar", never, { "executing": { "alias": "executing"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showHistory": { "alias": "showHistory"; "required": false; }; "showFormat": { "alias": "showFormat"; "required": false; }; "executeLabel": { "alias": "executeLabel"; "required": false; }; "formatLabel": { "alias": "formatLabel"; "required": false; }; "clearLabel": { "alias": "clearLabel"; "required": false; }; "historyLabel": { "alias": "historyLabel"; "required": false; }; "toolbarTemplate": { "alias": "toolbarTemplate"; "required": false; }; }, { "execute": "execute"; "format": "format"; "clear": "clear"; "toggleHistory": "toggleHistory"; }, never, never, true, never>;
+}

package/lib/components/database-manager/record-detail/record-detail.component.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, OnChanges, SimpleChanges, TemplateRef } from '@angular/core';
+import { EntityRegistryEntry, EntityFieldMeta } from '../types/database-manager.types';
+import * as i0 from "@angular/core";
+export declare class RecordDetailComponent implements OnChanges {
+    record?: Record<string, any>;
+    entity?: EntityRegistryEntry;
+    mode: 'view' | 'edit' | 'create';
+    saving: boolean;
+    saveLabel: string;
+    cancelLabel: string;
+    deleteLabel: string;
+    editLabel: string;
+    fieldTemplate?: TemplateRef<{
+        $implicit: EntityFieldMeta;
+        value: any;
+    }>;
+    headerTemplate?: TemplateRef<void>;
+    footerTemplate?: TemplateRef<void>;
+    save: EventEmitter<Record<string, any>>;
+    cancel: EventEmitter<void>;
+    delete: EventEmitter<Record<string, any>>;
+    formData: Record<string, any>;
+    ngOnChanges(changes: SimpleChanges): void;
+    get editableFields(): EntityFieldMeta[];
+    get allFields(): EntityFieldMeta[];
+    get isReadOnly(): boolean;
+    onFieldChange(field: EntityFieldMeta, value: any): void;
+    onSave(): void;
+    onCancel(): void;
+    onDelete(): void;
+    getInputType(field: EntityFieldMeta): string;
+    trackByName(_index: number, field: EntityFieldMeta): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordDetailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RecordDetailComponent, "tgm-record-detail", never, { "record": { "alias": "record"; "required": false; }; "entity": { "alias": "entity"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "saving": { "alias": "saving"; "required": false; }; "saveLabel": { "alias": "saveLabel"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; "deleteLabel": { "alias": "deleteLabel"; "required": false; }; "editLabel": { "alias": "editLabel"; "required": false; }; "fieldTemplate": { "alias": "fieldTemplate"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "footerTemplate": { "alias": "footerTemplate"; "required": false; }; }, { "save": "save"; "cancel": "cancel"; "delete": "delete"; }, never, never, true, never>;
+}

package/lib/components/database-manager/registry/entity-registry.d.ts

@@ -0,0 +1,16 @@
+import { EntityRegistryEntry } from '../types/database-manager.types';
+export declare const ENTITY_REGISTRY: EntityRegistryEntry[];
+/**
+ * Entity keys that are excluded from the browser by default.
+ * Consumers can override via `DatabaseManagerConfig.excludedEntities`.
+ */
+export declare const DEFAULT_EXCLUDED_ENTITIES: string[];
+/**
+ * Human-readable labels for each module code.
+ */
+export declare const MODULE_LABELS: Record<string, string>;
+/**
+ * Map of entity key → service class name (as exported from the SDK).
+ * Used by QueryExecutorService to resolve the correct service at runtime.
+ */
+export declare const ENTITY_SERVICE_MAP: Record<string, string>;

package/lib/components/database-manager/results-grid/results-grid.component.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { EntityFieldMeta } from '../types/database-manager.types';
+import * as i0 from "@angular/core";
+export declare class ResultsGridComponent {
+    data: any[];
+    columns: EntityFieldMeta[];
+    total: number;
+    page: number;
+    pageSize: number;
+    loading: boolean;
+    sortField?: string;
+    sortOrder?: 'ASC' | 'DESC';
+    showPagination: boolean;
+    showExport: boolean;
+    noResultsMessage: string;
+    loadingMessage: string;
+    rowClass: string;
+    cellTemplate?: TemplateRef<{
+        $implicit: any;
+        column: EntityFieldMeta;
+        row: any;
+    }>;
+    headerTemplate?: TemplateRef<{
+        $implicit: EntityFieldMeta;
+    }>;
+    emptyTemplate?: TemplateRef<void>;
+    paginationTemplate?: TemplateRef<{
+        page: number;
+        pageSize: number;
+        total: number;
+    }>;
+    sort: EventEmitter<{
+        field: string;
+        order: 'ASC' | 'DESC';
+    }>;
+    pageChange: EventEmitter<number>;
+    rowClick: EventEmitter<any>;
+    rowDoubleClick: EventEmitter<any>;
+    cellClick: EventEmitter<{
+        row: any;
+        column: EntityFieldMeta;
+        value: any;
+    }>;
+    exportData: EventEmitter<void>;
+    get visibleColumns(): EntityFieldMeta[];
+    get pageCount(): number;
+    get startRow(): number;
+    get endRow(): number;
+    onSort(field: string): void;
+    onRowClick(row: any): void;
+    onRowDoubleClick(row: any): void;
+    onCellClick(row: any, column: EntityFieldMeta): void;
+    prevPage(): void;
+    nextPage(): void;
+    goToPage(p: number): void;
+    onExport(): void;
+    formatValue(value: any, col: EntityFieldMeta): string;
+    trackByName(_index: number, col: EntityFieldMeta): string;
+    trackByIndex(index: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResultsGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResultsGridComponent, "tgm-results-grid", never, { "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "total": { "alias": "total"; "required": false; }; "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "sortField": { "alias": "sortField"; "required": false; }; "sortOrder": { "alias": "sortOrder"; "required": false; }; "showPagination": { "alias": "showPagination"; "required": false; }; "showExport": { "alias": "showExport"; "required": false; }; "noResultsMessage": { "alias": "noResultsMessage"; "required": false; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; }; "rowClass": { "alias": "rowClass"; "required": false; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "emptyTemplate": { "alias": "emptyTemplate"; "required": false; }; "paginationTemplate": { "alias": "paginationTemplate"; "required": false; }; }, { "sort": "sort"; "pageChange": "pageChange"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "cellClick": "cellClick"; "exportData": "exportData"; }, never, never, true, never>;
+}

package/lib/components/database-manager/services/entity-schema.service.d.ts

@@ -0,0 +1,37 @@
+import { EntityRegistryEntry, EntityModuleGroup, DatabaseManagerConfig } from '../types/database-manager.types';
+import * as i0 from "@angular/core";
+/**
+ * Provides filtered entity metadata based on the DatabaseManagerConfig.
+ * Filters by enabled modules and excluded entities, and groups entities by module.
+ */
+export declare class EntitySchemaService {
+    private cachedEntities;
+    private cachedGroups;
+    private currentConfig;
+    /**
+     * Returns all entity definitions filtered by the given config.
+     */
+    getEntities(config?: DatabaseManagerConfig): EntityRegistryEntry[];
+    /**
+     * Returns entities grouped by module, with human-readable labels.
+     */
+    getEntityGroups(config?: DatabaseManagerConfig, customLabels?: Record<string, string>): EntityModuleGroup[];
+    /**
+     * Find a single entity by its key.
+     */
+    getEntityByKey(key: string, config?: DatabaseManagerConfig): EntityRegistryEntry | undefined;
+    /**
+     * Returns entity keys that are visible (not excluded, module enabled).
+     */
+    getVisibleEntityKeys(config?: DatabaseManagerConfig): string[];
+    /**
+     * Check whether an entity key is accessible under the current config.
+     */
+    isEntityVisible(key: string, config?: DatabaseManagerConfig): boolean;
+    /**
+     * Invalidate cached data (call when config changes).
+     */
+    invalidateCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitySchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntitySchemaService>;
+}

package/lib/components/database-manager/services/query-executor.service.d.ts

@@ -0,0 +1,57 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { QueryModel, QueryResult, DatabaseManagerConfig } from '../types/database-manager.types';
+import { EntitySchemaService } from './entity-schema.service';
+import { BaseCrudService } from '../../../services/api/base-crud.service';
+import * as i0 from "@angular/core";
+/**
+ * Translates a QueryModel (JSON from the editor) into BaseCrudService.getAll() calls
+ * and returns a QueryResult.
+ */
+export declare class QueryExecutorService {
+    private injector;
+    private entitySchema;
+    /** Cache of resolved service instances keyed by entity key */
+    private serviceCache;
+    constructor(injector: Injector, entitySchema: EntitySchemaService);
+    /**
+     * Execute a query model against the entity's CRUD service.
+     */
+    execute(query: QueryModel, config?: DatabaseManagerConfig): Observable<QueryResult>;
+    /**
+     * Parse raw JSON string into a QueryModel, with validation.
+     */
+    parseQuery(raw: string): QueryModel;
+    /**
+     * Format a QueryModel into a pretty-printed JSON string.
+     */
+    formatQuery(query: QueryModel): string;
+    /**
+     * Create a default query for an entity key.
+     */
+    defaultQuery(entityKey: string, pageSize?: number): QueryModel;
+    /**
+     * Resolve a BaseCrudService instance for an entity key.
+     */
+    private resolveService;
+    /**
+     * Try to find an already-injected BaseCrudService by its resource path.
+     * This iterates the known service class names and tries to inject them.
+     */
+    private findServiceByResourcePath;
+    /**
+     * Register a service instance for an entity key.
+     * This allows the consuming app to provide service references explicitly.
+     */
+    registerService(entityKey: string, service: BaseCrudService<any>): void;
+    /**
+     * Register multiple services at once.
+     */
+    registerServices(services: Record<string, BaseCrudService<any>>): void;
+    /**
+     * Clear the service cache.
+     */
+    clearServiceCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryExecutorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryExecutorService>;
+}

package/lib/components/database-manager/table-data-viewer/table-data-viewer.component.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter, OnChanges, OnDestroy, SimpleChanges, TemplateRef } from '@angular/core';
+import { EntityRegistryEntry, EntityFieldMeta, DatabaseManagerConfig } from '../types/database-manager.types';
+import { QueryExecutorService } from '../services/query-executor.service';
+import { EntitySchemaService } from '../services/entity-schema.service';
+import * as i0 from "@angular/core";
+export declare class TableDataViewerComponent implements OnChanges, OnDestroy {
+    private queryExecutor;
+    private entitySchema;
+    entityKey?: string;
+    config?: DatabaseManagerConfig;
+    pageSize: number;
+    showFilters: boolean;
+    showCreate: boolean;
+    showDelete: boolean;
+    emptyMessage: string;
+    loadingMessage: string;
+    rowTemplate?: TemplateRef<any>;
+    filterTemplate?: TemplateRef<any>;
+    toolbarTemplate?: TemplateRef<any>;
+    view: EventEmitter<any>;
+    edit: EventEmitter<any>;
+    delete: EventEmitter<any>;
+    create: EventEmitter<void>;
+    pageChange: EventEmitter<number>;
+    filterChange: EventEmitter<Record<string, any>>;
+    entity?: EntityRegistryEntry;
+    data: any[];
+    total: number;
+    page: number;
+    loading: boolean;
+    sortField: string;
+    sortOrder: 'ASC' | 'DESC';
+    filters: Record<string, any>;
+    executionTime: number;
+    private subscription?;
+    constructor(queryExecutor: QueryExecutorService, entitySchema: EntitySchemaService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    get columns(): EntityFieldMeta[];
+    onSort(event: {
+        field: string;
+        order: 'ASC' | 'DESC';
+    }): void;
+    onPageChange(page: number): void;
+    onView(row: any): void;
+    onEdit(row: any): void;
+    onDelete(row: any): void;
+    onCreate(): void;
+    onFilterChange(field: string, value: any): void;
+    refresh(): void;
+    private fetchData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDataViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableDataViewerComponent, "tgm-table-data-viewer", never, { "entityKey": { "alias": "entityKey"; "required": false; }; "config": { "alias": "config"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "showFilters": { "alias": "showFilters"; "required": false; }; "showCreate": { "alias": "showCreate"; "required": false; }; "showDelete": { "alias": "showDelete"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; }; "rowTemplate": { "alias": "rowTemplate"; "required": false; }; "filterTemplate": { "alias": "filterTemplate"; "required": false; }; "toolbarTemplate": { "alias": "toolbarTemplate"; "required": false; }; }, { "view": "view"; "edit": "edit"; "delete": "delete"; "create": "create"; "pageChange": "pageChange"; "filterChange": "filterChange"; }, never, never, true, never>;
+}

package/lib/components/database-manager/table-structure/table-structure.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { EntityRegistryEntry, EntityFieldMeta } from '../types/database-manager.types';
+import * as i0 from "@angular/core";
+export declare class TableStructureComponent {
+    entity?: EntityRegistryEntry;
+    containerClass: string;
+    fieldTemplate?: TemplateRef<{
+        $implicit: EntityFieldMeta;
+    }>;
+    fieldClick: EventEmitter<EntityFieldMeta>;
+    onFieldClick(field: EntityFieldMeta): void;
+    getTypeBadgeClass(type: string): string;
+    trackByName(_index: number, field: EntityFieldMeta): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableStructureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableStructureComponent, "tgm-table-structure", never, { "entity": { "alias": "entity"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; "fieldTemplate": { "alias": "fieldTemplate"; "required": false; }; }, { "fieldClick": "fieldClick"; }, never, never, true, never>;
+}

package/lib/components/database-manager/types/database-manager.types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Database Manager Types
+ * All interfaces for the Navicat/DBeaver-style entity browser UI.
+ */
+export interface EntityFieldMeta {
+    name: string;
+    label: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'enum' | 'json' | 'array';
+    sortable?: boolean;
+    filterable?: boolean;
+    editable?: boolean;
+    required?: boolean;
+    enumValues?: string[];
+    description?: string;
+    hidden?: boolean;
+}
+export interface EntityRegistryEntry {
+    key: string;
+    name: string;
+    module: string;
+    icon?: string;
+    description?: string;
+    fields: EntityFieldMeta[];
+    serviceClass?: string;
+    resourcePath?: string;
+    excludable?: boolean;
+}
+export interface QueryModel {
+    entity: string;
+    select?: string[];
+    filters?: Record<string, any>;
+    sort?: string;
+    order?: 'ASC' | 'DESC';
+    page?: number;
+    pageSize?: number;
+}
+export interface QueryResult {
+    data: any[];
+    total: number;
+    page: number;
+    pageSize: number;
+    executionTime: number;
+    entity: string;
+}
+export interface DatabaseManagerConfig {
+    enabledModules?: string[];
+    excludedEntities?: string[];
+    defaultPageSize?: number;
+    maxPageSize?: number;
+    enableMonaco?: boolean;
+    readOnly?: boolean;
+    theme?: 'dark' | 'light';
+    monacoOptions?: any;
+    sidebarWidth?: number;
+    editorHeight?: number;
+}
+export interface EditorTab {
+    id: string;
+    title: string;
+    type: 'query' | 'table-data' | 'table-structure';
+    entityKey?: string;
+    query?: string;
+    result?: QueryResult;
+    dirty?: boolean;
+}
+export interface EntityModuleGroup {
+    code: string;
+    label: string;
+    entities: EntityRegistryEntry[];
+    expanded?: boolean;
+}

package/lib/components/reporting/export-button/export-button.component.d.ts

@@ -0,0 +1,50 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { ExportService } from '../../../services/api/export.service';
+import * as i0 from "@angular/core";
+export type ExportFormat = 'excel' | 'csv' | 'pdf';
+export declare class ExportButtonComponent {
+    private exportService;
+    entityType: string;
+    entityIds?: number[];
+    formats: ExportFormat[];
+    disabled: boolean;
+    autoExport: boolean;
+    label: string;
+    excelLabel: string;
+    csvLabel: string;
+    pdfLabel: string;
+    buttonClass: string;
+    dropdownClass: string;
+    buttonTemplate?: TemplateRef<{
+        label: string;
+        open: boolean;
+        disabled: boolean;
+        exporting: boolean;
+        toggle: () => void;
+    }>;
+    menuItemTemplate?: TemplateRef<{
+        $implicit: ExportFormat;
+        label: string;
+        onExport: () => void;
+    }>;
+    exportStarted: EventEmitter<{
+        format: ExportFormat;
+        entityType: string;
+    }>;
+    exportCompleted: EventEmitter<Blob>;
+    exportError: EventEmitter<Error>;
+    dropdownOpen: boolean;
+    exporting: boolean;
+    private entityMethodMap;
+    constructor(exportService: ExportService);
+    onDocumentClick(): void;
+    toggleDropdown: () => void;
+    onButtonClick(event: Event): void;
+    onMenuClick(event: Event): void;
+    onExport(format: ExportFormat): void;
+    getFormatLabel(format: ExportFormat): string;
+    trackByFormat(_index: number, format: ExportFormat): string;
+    private buildEntityMethodMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExportButtonComponent, "tgm-export-button", never, { "entityType": { "alias": "entityType"; "required": false; }; "entityIds": { "alias": "entityIds"; "required": false; }; "formats": { "alias": "formats"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "autoExport": { "alias": "autoExport"; "required": false; }; "label": { "alias": "label"; "required": false; }; "excelLabel": { "alias": "excelLabel"; "required": false; }; "csvLabel": { "alias": "csvLabel"; "required": false; }; "pdfLabel": { "alias": "pdfLabel"; "required": false; }; "buttonClass": { "alias": "buttonClass"; "required": false; }; "dropdownClass": { "alias": "dropdownClass"; "required": false; }; "buttonTemplate": { "alias": "buttonTemplate"; "required": false; }; "menuItemTemplate": { "alias": "menuItemTemplate"; "required": false; }; }, { "exportStarted": "exportStarted"; "exportCompleted": "exportCompleted"; "exportError": "exportError"; }, never, never, true, never>;
+}