bways-report 0.1.5 → 0.1.7

package/lib/core/config/bways-report-config.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Simplified configuration for bways-report.
+ *
+ * This is the developer-facing config object that makes integration
+ * as simple as 3–4 endpoint URLs + optional overrides.
+ * The normalizer converts this into the internal `ReportingConfig`
+ * plus adapter wiring decisions.
+ */
+import { Type } from '@angular/core';
+import { SessionContextProvider, SessionContextSource } from '../tokens/session-context.token';
+/**
+ * Palette component category names the developer can use
+ * when restricting the designer component palette.
+ *
+ * Maps to internal registry category IDs:
+ * - `formInputs`    → `input`
+ * - `actionButtons` → `action`
+ * - `displayLabels` → `display`
+ * - `dataLookups`   → `data`
+ * - `layout`        → `layout`
+ */
+export type PaletteCategory = 'formInputs' | 'actionButtons' | 'displayLabels' | 'dataLookups' | 'layout';
+/**
+ * Mapping from friendly palette category names to internal category IDs.
+ */
+export declare const PALETTE_CATEGORY_MAP: Record<PaletteCategory, string>;
+/**
+ * Simplified, developer-facing configuration for bways-report.
+ *
+ * @example
+ * ```typescript
+ * const reportConfig: BwaysReportConfig = {
+ *   spEndpoint:      '/api/reporting/procedures',
+ *   tablesEndpoint:  '/api/reporting/tables',
+ *   executeEndpoint: '/api/reporting/execute',
+ *   reportsEndpoint: '/api/reporting/reports',
+ *   components: ['formInputs', 'actionButtons', 'displayLabels'],
+ *   autoParameter: true,
+ *   session: () => inject(AuthService).session(),
+ *   routeBase: 'reports',
+ * };
+ * ```
+ */
+export interface BwaysReportConfig {
+    /**
+     * GET endpoint returning the list of stored procedures with their parameters.
+     * Response: `[{ name, schema, parameters: [{ name, sqlType, required, defaultValue? }] }]`
+     */
+    spEndpoint: string;
+    /**
+     * GET endpoint returning the list of tables/views with their columns.
+     * Response: `[{ name, schema, type: 'table'|'view', columns: [{ name, sqlType }] }]`
+     */
+    tablesEndpoint: string;
+    /**
+     * POST endpoint that runs a stored procedure or table query and returns rows.
+     * Body: `{ kind: 'procedure'|'table', name, schema, parameters, columns?, top? }`
+     * Response: `rows[]`
+     */
+    executeEndpoint: string;
+    /**
+     * Optional POST endpoint for fetching dropdown master data and lookup options.
+     * Defaults to replacing `/execute` with `/lookup` if omitted.
+     */
+    lookupEndpoint?: string;
+    /**
+     * Optional CRUD endpoint for saving/loading report page definitions.
+     * When omitted, reports are saved to browser localStorage with a console warning.
+     * - GET    → list saved reports
+     * - GET /:id → load a specific report
+     * - POST   → save a new or updated report
+     * - DELETE /:id → delete a report
+     */
+    reportsEndpoint?: string;
+    /**
+     * Component palette groups to show in the designer.
+     * Defaults to all groups when not specified.
+     *
+     * @example ['formInputs', 'actionButtons', 'displayLabels']
+     */
+    components?: PaletteCategory[];
+    /**
+     * When true, stored procedure parameters like `@BranchId`, `@CompanyId`
+     * are automatically bound from the session context.
+     * Requires `session` to be provided.
+     *
+     * @default true
+     */
+    autoParameter?: boolean;
+    /**
+     * Session context provider for auto-parameter binding.
+     * Can be a service class implementing `SessionContextProvider`,
+     * a plain object, a factory function, an Observable, or a Signal.
+     *
+     * @example
+     * session: PlaygroundSessionService
+     * session: () => inject(AuthService).session()
+     * session: { branchId: 1, companyId: 10 }
+     */
+    session?: Type<SessionContextProvider> | SessionContextSource | (() => Record<string, unknown>);
+    /**
+     * Optional service class implementing `SessionContextProvider`.
+     * Equivalent to `session: MySessionService`.
+     */
+    sessionProvider?: Type<SessionContextProvider>;
+    /**
+     * Base path for live report pages.
+     * Generated report pages open at `/<routeBase>/<slug>`.
+     *
+     * @default 'reports'
+     */
+    routeBase?: string;
+    /**
+     * Optional Angular component for rendering data grids.
+     * Pass your grid component (BWays-grid, AG Grid wrapper, etc.).
+     */
+    grid?: Type<unknown>;
+    /**
+     * Optional Angular component for rendering charts.
+     */
+    chart?: Type<unknown>;
+    /** Default page size for grid results. @default 25 */
+    defaultPageSize?: number;
+    /** Date format string used across the library. @default 'dd/MM/yyyy' */
+    dateFormat?: string;
+    /** Timeout in ms for lookup/execute queries. @default 300000 */
+    lookupTimeoutMs?: number;
+}
+/**
+ * Result of normalizing a `BwaysReportConfig` for internal use.
+ */
+export interface NormalizedBwaysConfig {
+    /** Endpoint URLs */
+    spEndpoint: string;
+    tablesEndpoint: string;
+    executeEndpoint: string;
+    lookupEndpoint: string | null;
+    reportsEndpoint: string | null;
+    /** Resolved internal category IDs (e.g. ['input', 'action', 'display']) */
+    allowedCategories: string[] | null;
+    /** Whether auto-parameter binding is enabled */
+    autoParameter: boolean;
+    /** Route base path */
+    routeBase: string;
+    /** Session source */
+    session: Type<SessionContextProvider> | SessionContextSource | (() => Record<string, unknown>) | null;
+    sessionProvider: Type<SessionContextProvider> | null;
+    /** Grid component */
+    gridComponent: Type<unknown> | null;
+    /** Chart component */
+    chartComponent: Type<unknown> | null;
+    /** General config values */
+    defaultPageSize: number;
+    dateFormat: string;
+    lookupTimeoutMs: number;
+}
+/**
+ * Normalizes a `BwaysReportConfig` into the internal format.
+ * Validates required fields and maps friendly names to internal IDs.
+ */
+export declare function normalizeBwaysConfig(config: BwaysReportConfig): NormalizedBwaysConfig;

package/lib/core/index.d.ts

@@ -1,3 +1,4 @@
+export * from './config/bways-report-config';
 export * from './models';
 export * from './registry';
 export * from './tokens';

package/lib/core/models/report-definition.model.d.ts

@@ -37,6 +37,14 @@ export interface ReportSummary {
     description?: string;
     /** Category or group for organizing reports. */
     category?: string;
+    /** URL-friendly slug for routing. */
+    slug?: string;
+    /** Menu group for organizing reports in navigation. */
+    menuGroup?: string;
+    /** Sort order within the menu group. */
+    menuOrder?: number;
+    /** Optional icon name. */
+    icon?: string;
     /** Current version number. */
     version: number;
     /** Whether the report is published (vs. draft). */
@@ -91,6 +99,14 @@ export interface ReportDefinition {
     grid?: ReportGridDefinition;
     /** Access control settings. */
     permissions?: ReportPermissionDefinition;
+    /** URL-friendly slug for routing (e.g. 'sale-report'). Auto-generated from name if not set. */
+    slug?: string;
+    /** Menu group for organizing reports in the sidebar (e.g. 'Sales', 'Finance'). */
+    menuGroup?: string;
+    /** Sort order within the menu group. Lower numbers appear first. */
+    menuOrder?: number;
+    /** Optional icon name for menu display. */
+    icon?: string;
     /** Custom metadata for host-specific extensions. */
     metadata?: Record<string, unknown>;
     /** ISO date of creation. */

package/lib/core/services/index.d.ts

@@ -2,3 +2,4 @@ export { DynamicFormBuilder } from './dynamic-form-builder.service';
 export { ReportSessionContextService } from './report-session-context.service';
 export type { SessionParamMatch, DerivedParametersResult, } from './report-session-context.service';
 export { ReportStorageService } from './report-storage.service';
+export { ReportDataDiscoveryService } from './report-data-discovery.service';

package/lib/core/services/report-data-discovery.service.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { DatabaseEntityMetadata, DatabaseEntityType, ProcedureParameterMetadata } from '../../data-access/contracts/schema-discovery.contract';
+import { GridColumnDefinition } from '../models/report-grid.model';
+import * as i0 from "@angular/core";
+/**
+ * Centralized service for discovering database schema entities, parameters,
+ * and column definitions.
+ *
+ * Provides a unified static + dynamic detection pipeline:
+ * If static schema metadata discovery fails (e.g. SQL Server stored procedures
+ * using #temp tables that cannot be analyzed statically), it automatically
+ * falls back to executing a safe dynamic sample query with the active parameter
+ * values and extracting column definitions from the result dataset.
+ */
+export declare class ReportDataDiscoveryService {
+    private readonly discoveryAdapter;
+    private readonly lookupAdapter;
+    private readonly sessionService;
+    /**
+     * Retrieves all database tables, views, and stored procedures.
+     */
+    getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]>;
+    /**
+     * Retrieves stored procedure parameter metadata.
+     */
+    getParameters(procedureName: string, schema?: string): Observable<ProcedureParameterMetadata[]>;
+    /**
+     * Unified column detection:
+     * 1. Attempts static schema discovery via ReportSchemaDiscoveryAdapter.
+     * 2. If static discovery returns 0 columns or throws an error (e.g. SQL Error 11526 with #temp tables),
+     *    automatically runs dynamic sample query via ReportLookupAdapter using resolved parameters.
+     */
+    autoDetectColumns(entityName: string, entityType?: 'table' | 'stored_procedure', mappings?: Record<string, unknown>, schema?: string): Observable<GridColumnDefinition[]>;
+    private mapStaticColumnsToGrid;
+    private fallbackDynamicDetection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportDataDiscoveryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReportDataDiscoveryService>;
+}

package/lib/core/services/report-session-context.service.d.ts

@@ -27,6 +27,7 @@ export interface DerivedParametersResult {
 export declare class ReportSessionContextService implements OnDestroy {
     private readonly rawSource;
     private readonly sessionProvider;
+    private readonly reportingConfig;
     /** Internal manual runtime session overrides (e.g. set via setSessionContext or setSessionParameter) */
     private readonly manualRuntimeContext;
     private readonly latestObservableValue;

package/lib/core/tokens/reporting-config.token.d.ts

@@ -21,6 +21,24 @@ export interface ReportingConfig {
     apiBaseUrl?: string;
     /** Whether automatic backend schema discovery (SPs & Tables) is enabled. */
     enableSchemaDiscovery?: boolean;
+    /** Optional timeout in milliseconds for dropdown lookup queries (defaults to 300000ms / 5 minutes). */
+    lookupTimeoutMs?: number;
+    /**
+     * Internal category IDs to show in the designer palette.
+     * When null/undefined, all categories are shown.
+     * Set by the BwaysReportConfig normalizer from friendly names.
+     */
+    allowedCategories?: string[] | null;
+    /**
+     * Whether to auto-bind SP parameters from the session context.
+     * @default true
+     */
+    autoParameter?: boolean;
+    /**
+     * Base route path for live report pages.
+     * @default 'reports'
+     */
+    routeBase?: string;
 }
 /**
  * Injection token for the grid component.

package/lib/core/utils/data-normalization.util.d.ts

@@ -13,3 +13,13 @@ export declare function extractRowArray<T = unknown>(response: unknown): T[];
  * Searches for exact match first, then lower-cased match, then normalized (ignoring underscores/dashes).
  */
 export declare function getFieldCaseInsensitive(record: Record<string, unknown> | null | undefined, targetKey: string): unknown;
+export interface NormalizedLookupOption {
+    value: string | number;
+    label: string;
+    raw?: Record<string, unknown>;
+}
+/**
+ * Normalizes an arbitrary database record into a standardized { value, label, raw } option item.
+ * Supports case-insensitive field matching and intelligent heuristics for SQL Server columns.
+ */
+export declare function extractLookupOptionItem(row: unknown, valueField?: string, displayField?: string): NormalizedLookupOption;

package/lib/core/utils/report-parameter.util.d.ts

@@ -8,13 +8,30 @@ export declare function resolveContextPreset(key: string): string;
  * and compound date ranges (e.g. dateRange.from, dateRange_from, dateRangeFrom).
  */
 export declare function resolveCanvasFieldValue(formValues: Record<string, unknown>, inner: string): unknown;
+/**
+ * Sanitizes T-SQL parameter literals copied from SSMS, profilers, or SQL scripts:
+ * - Strips outer double quotes: "..."
+ * - Strips outer T-SQL quotes: N'...' or '...'
+ * - Unescapes doubled single quotes: '' -> '
+ */
+export declare function sanitizeSqlParamLiteral(val: unknown): unknown;
+export interface ParsedSqlExec {
+    procedureName?: string;
+    parameters: Record<string, string | number | boolean>;
+}
+/**
+ * Parses an SSMS / T-SQL EXEC statement such as:
+ * exec Get_HelpList @chrCOMPANYID=N'101',@chrTableName=N'MSTACCTGLSUB',@intExecFlag=1
+ * Extracts procedure name and unescapes parameter values.
+ */
+export declare function parseSqlExecStatement(sql: string): ParsedSqlExec | null;
 /**
  * Resolves one raw mapping value against session + canvas form values.
  * - `{{session.branchId}}`  -> session value (case-insensitive)
  * - `{{context.today}}`     -> computed date
  * - `{{fromDate}}`          -> value of canvas field with key `fromDate` (case-insensitive)
  * - `{{dateRange.from}}`    -> value of nested from property
- * - anything else           -> returned unchanged (fixed value)
+ * - anything else           -> sanitized literal value (fixed value)
  */
 export declare function resolveParameterValue(raw: unknown, session: Record<string, unknown>, formValues: Record<string, unknown>): unknown;
 /** Resolves every mapping into concrete values (de-duplicating `@name` / `name`). */

package/lib/data-access/adapters/endpoint-datasource.adapter.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { ReportDataSourceAdapter } from '../contracts/data-source.contract';
+import { ReportDataSourceDefinition } from '../../core/models/report-datasource.model';
+import * as i0 from "@angular/core";
+export declare class EndpointDataSourceAdapter extends ReportDataSourceAdapter {
+    private readonly http;
+    private readonly endpoints;
+    private readonly sessionService;
+    execute(dataSource: ReportDataSourceDefinition, parameters: Record<string, unknown>): Observable<unknown[]>;
+    private resolveKind;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EndpointDataSourceAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EndpointDataSourceAdapter>;
+}

package/lib/data-access/adapters/endpoint-lookup.adapter.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { LookupOptionItem, LookupQueryRequest, ReportLookupAdapter } from '../contracts/lookup.contract';
+import * as i0 from "@angular/core";
+export declare class EndpointLookupAdapter extends ReportLookupAdapter {
+    private readonly http;
+    private readonly endpoints;
+    private readonly sessionService;
+    private readonly cache;
+    private readonly inFlight;
+    fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]>;
+    private generateCacheKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EndpointLookupAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EndpointLookupAdapter>;
+}

package/lib/data-access/adapters/endpoint-masterdata.adapter.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { MasterDataItem, MasterDataOptions, MasterDataProvider } from '../contracts/master-data.provider';
+import * as i0 from "@angular/core";
+export declare class EndpointMasterDataAdapter extends MasterDataProvider {
+    private readonly http;
+    private readonly endpoints;
+    private readonly sessionService;
+    getMasterData(masterName: string, options?: MasterDataOptions): Observable<MasterDataItem[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EndpointMasterDataAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EndpointMasterDataAdapter>;
+}

package/lib/data-access/adapters/endpoint-persistence.adapter.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { ReportDefinition, ReportSummary } from '../../core/models/report-definition.model';
+import { ReportPersistenceAdapter } from '../contracts/report-persistence.contract';
+import * as i0 from "@angular/core";
+export declare class EndpointPersistenceAdapter extends ReportPersistenceAdapter {
+    private readonly http;
+    private readonly endpoints;
+    load(reportId: string): Observable<ReportDefinition>;
+    save(report: ReportDefinition): Observable<ReportDefinition>;
+    list(): Observable<ReportSummary[]>;
+    delete(reportId: string): Observable<void>;
+    publish(reportId: string, version: number): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EndpointPersistenceAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EndpointPersistenceAdapter>;
+}

package/lib/data-access/adapters/endpoint-schema-discovery.adapter.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { DatabaseEntityMetadata, DatabaseEntityType, EntityColumnMetadata, ProcedureParameterMetadata, ReportSchemaDiscoveryAdapter } from '../contracts/schema-discovery.contract';
+import * as i0 from "@angular/core";
+export declare class EndpointSchemaDiscoveryAdapter extends ReportSchemaDiscoveryAdapter {
+    private readonly http;
+    private readonly endpoints;
+    /** Cached list responses so we don't re-fetch on every getColumns/getParameters call */
+    private spCache$;
+    private tableCache$;
+    private spItems;
+    private tableItems;
+    getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]>;
+    getColumns(entityName: string, schema?: string, type?: DatabaseEntityType): Observable<EntityColumnMetadata[]>;
+    getParameters(entityName: string, schema?: string): Observable<ProcedureParameterMetadata[]>;
+    /** Fetch and cache the SP list from the endpoint */
+    private fetchSps;
+    /** Fetch and cache the tables list from the endpoint */
+    private fetchTables;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EndpointSchemaDiscoveryAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EndpointSchemaDiscoveryAdapter>;
+}

package/lib/data-access/adapters/endpoint-tokens.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Injection tokens for the endpoint-based adapter configuration.
+ *
+ * When the developer uses `BwaysReportConfig` (simple config), these tokens
+ * are populated with the endpoint URLs so adapters can inject them.
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Endpoint URLs used by the endpoint-based adapters.
+ */
+export interface BwaysReportEndpoints {
+    spEndpoint: string;
+    tablesEndpoint: string;
+    executeEndpoint: string;
+    lookupEndpoint?: string | null;
+    reportsEndpoint: string | null;
+}
+/**
+ * Injection token for the endpoint URLs.
+ */
+export declare const BWAYS_REPORT_ENDPOINTS: InjectionToken<BwaysReportEndpoints>;

package/lib/data-access/adapters/http-lookup.adapter.d.ts

@@ -3,13 +3,14 @@ import { LookupOptionItem, LookupQueryRequest, ReportLookupAdapter } from '../co
 import * as i0 from "@angular/core";
 /**
  * Built-in HTTP adapter for fetching dropdown options from backend database tables and SPs.
- * Includes in-memory caching with TTL and rich fallback mock data for testing.
+ * Includes in-memory caching with TTL, in-flight request deduplication, and fallback mock data.
  */
 export declare class HttpReportLookupAdapter extends ReportLookupAdapter {
     private readonly http;
     private readonly config;
     private readonly sessionService;
     private readonly cache;
+    private readonly inFlight;
     private readonly mockDataStore;
     fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]>;
     private setCache;

package/lib/data-access/adapters/index.d.ts

@@ -5,3 +5,10 @@ export { HttpReportPersistenceAdapter, HttpPersistenceAdapter, } from './http-pe
 export { HttpMasterDataAdapter, } from './http-masterdata.adapter';
 export { LocalStorageReportPersistenceAdapter, } from './local-storage-persistence.adapter';
 export { MockReportDataSourceAdapter, } from './mock-datasource.adapter';
+export { EndpointSchemaDiscoveryAdapter } from './endpoint-schema-discovery.adapter';
+export { EndpointDataSourceAdapter } from './endpoint-datasource.adapter';
+export { EndpointLookupAdapter } from './endpoint-lookup.adapter';
+export { EndpointPersistenceAdapter } from './endpoint-persistence.adapter';
+export { EndpointMasterDataAdapter } from './endpoint-masterdata.adapter';
+export { BWAYS_REPORT_ENDPOINTS } from './endpoint-tokens';
+export type { BwaysReportEndpoints } from './endpoint-tokens';

package/lib/data-access/contracts/lookup.contract.d.ts

@@ -7,8 +7,8 @@ export interface LookupQueryRequest {
     sourceType: DropdownSourceType;
     entityName?: string;
     schema?: string;
-    valueField: string;
-    displayField: string;
+    valueField?: string;
+    displayField?: string;
     filter?: Record<string, unknown>;
     parameters?: Record<string, unknown>;
     limit?: number;

package/lib/features/designer/components/component-palette/component-palette.component.d.ts

@@ -3,6 +3,7 @@ import * as i0 from "@angular/core";
 export declare class ComponentPaletteComponent {
     private readonly registry;
     private readonly designerState;
+    private readonly reportingConfig;
     readonly collapseRequested: import("@angular/core").OutputEmitterRef<void>;
     readonly searchQuery: import("@angular/core").WritableSignal<string>;
     /** Layout view mode: 'grid' (2-column side-by-side grid) or 'list' (compact row list). Defaults to 'grid'. */

package/lib/features/designer/components/design-canvas/design-canvas.component.d.ts

@@ -1,10 +1,13 @@
+import { OnDestroy } from '@angular/core';
 import { FormControl, FormGroup } from '@angular/forms';
 import { CdkDragDrop } from '@angular/cdk/drag-drop';
 import { ReportComponentDefinition } from '../../../../core/models/report-component.model';
 import { getComponentIconName } from '../../utilities/canvas-layout.util';
 import * as i0 from "@angular/core";
-export declare class DesignCanvasComponent {
+export declare class DesignCanvasComponent implements OnDestroy {
     private readonly designerState;
+    private gridFilterDebounceTimer;
+    private pendingGridState;
     private readonly templateService;
     private readonly formBuilder;
     private readonly executionService;
@@ -17,7 +20,7 @@ export declare class DesignCanvasComponent {
     readonly highlightedFieldKeys: import("@angular/core").WritableSignal<Set<string>>;
     readonly layoutJustUpdated: import("@angular/core").WritableSignal<boolean>;
     isFieldHighlighted(comp: ReportComponentDefinition): boolean;
-    onControlInteract(comp: ReportComponentDefinition, event: Event): void;
+    onControlInteract(comp: ReportComponentDefinition, event?: Event): void;
     getGridSummaryText(): string;
     highlightMissingFields(fields: string[]): void;
     readonly canvasGridData: import("@angular/core").WritableSignal<unknown[]>;
@@ -56,6 +59,7 @@ export declare class DesignCanvasComponent {
     addResultGrid(event?: MouseEvent): void;
     executeCanvasReport(event?: MouseEvent): void;
     onCanvasButtonClick(comp: ReportComponentDefinition, event: MouseEvent): void;
+    ngOnDestroy(): void;
     onCanvasGridStateChange(state: any): void;
     onCanvasColumnDefsChange(defs: any[]): void;
     removeGrid(event?: MouseEvent): void;

package/lib/features/designer/components/dialogs/report-saved-dialog.component.d.ts

@@ -0,0 +1,34 @@
+import { ReportDefinition } from '../../../../core/models/report-definition.model';
+import * as i0 from "@angular/core";
+export interface ReportSavedDialogData {
+    report: ReportDefinition;
+    routeBase?: string;
+}
+export interface ReportSavedDialogResult {
+    action: 'back_to_designer' | 'open_live_page';
+    report: ReportDefinition;
+}
+export declare class ReportSavedDialogComponent {
+    private readonly dialogRef;
+    private readonly data;
+    private readonly store;
+    private readonly reportingConfig;
+    private readonly router;
+    readonly report: ReportDefinition;
+    readonly baseRoute: import("@angular/core").WritableSignal<string>;
+    readonly name: import("@angular/core").WritableSignal<string>;
+    readonly slug: import("@angular/core").WritableSignal<string>;
+    readonly menuGroup: import("@angular/core").WritableSignal<string>;
+    readonly isPublished: import("@angular/core").WritableSignal<boolean>;
+    readonly copied: import("@angular/core").WritableSignal<boolean>;
+    readonly savedStateMessage: import("@angular/core").WritableSignal<string | null>;
+    readonly fullRoute: import("@angular/core").Signal<string>;
+    readonly currentPreviewDef: import("@angular/core").Signal<ReportDefinition>;
+    onNameChange(newName: string): void;
+    copyRoute(): void;
+    saveUpdatedDefinition(): ReportDefinition;
+    close(action?: 'back_to_designer' | 'open_live_page'): void;
+    openLivePage(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportSavedDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReportSavedDialogComponent, "rpt-report-saved-dialog", never, {}, {}, never, never, true, never>;
+}

package/lib/features/designer/components/property-editor/parameter-binding-editor.component.d.ts

@@ -19,6 +19,11 @@ export declare class ParameterBindingEditorComponent {
     readonly sessionMatch: import("@angular/core").Signal<import("../../../../core/services/report-session-context.service").SessionParamMatch | null>;
     readonly friendlyLabel: import("@angular/core").Signal<string>;
     readonly displayType: import("@angular/core").Signal<"Date" | "Text" | "Number" | "Yes / No">;
+    readonly isCurrentValue: (val: string | number) => boolean;
+    readonly paramQuickSuggestions: import("@angular/core").Signal<{
+        label: string;
+        value: string | number;
+    }[]>;
     readonly compatibleControls: import("@angular/core").Signal<ReportComponentDefinition[]>;
     readonly hasValue: import("@angular/core").Signal<boolean>;
     readonly activeMode: import("@angular/core").Signal<ParameterBindingMode>;
@@ -26,6 +31,7 @@ export declare class ParameterBindingEditorComponent {
     readonly selectedControlKey: import("@angular/core").Signal<string>;
     readonly selectedContextKey: import("@angular/core").Signal<string>;
     readonly booleanFixedValue: import("@angular/core").Signal<boolean>;
+    readonly isLongTextInput: import("@angular/core").Signal<boolean>;
     setMode(mode: ParameterBindingMode): void;
     onControlSelected(key: string): void;
     onBooleanChanged(checked: boolean): void;

package/lib/features/designer/components/property-editor/property-editor-action.component.d.ts

@@ -14,6 +14,9 @@ export interface ActionTypeOption {
 export declare class PropertyEditorActionComponent {
     private readonly designerState;
     private readonly discoveryAdapter;
+    private readonly lookupAdapter;
+    private readonly sessionService;
+    private readonly dataDiscovery;
     readonly comp: import("@angular/core").InputSignal<ReportComponentDefinition>;
     readonly updateProperty: import("@angular/core").OutputEmitterRef<{
         key: string;

package/lib/features/designer/components/property-editor/property-editor-datasource.component.d.ts

@@ -1,15 +1,19 @@
-import { OnInit } from '@angular/core';
+import { OnDestroy, OnInit } from '@angular/core';
 import { ComponentDataSourceDefinition, DropdownSourceType, ReportComponentDefinition } from '../../../../core/models/report-component.model';
 import { DatabaseEntityMetadata, EntityColumnMetadata, ProcedureParameterMetadata } from '../../../../data-access/contracts/schema-discovery.contract';
+import { SearchableSelectOption } from '../../../../primitives/components';
 import * as i0 from "@angular/core";
 export interface StaticOptionItem {
     key: string;
     label: string;
 }
-export declare class PropertyEditorDatasourceComponent implements OnInit {
+export declare class PropertyEditorDatasourceComponent implements OnInit, OnDestroy {
     private readonly discoveryAdapter;
     private readonly sessionService;
     private readonly designerState;
+    private lastLoadedKey;
+    private columnsSub?;
+    private paramsSub?;
     readonly comp: import("@angular/core").InputSignal<ReportComponentDefinition>;
     readonly allComponents: import("@angular/core").InputSignal<ReportComponentDefinition[]>;
     readonly updateDataSource: import("@angular/core").OutputEmitterRef<ComponentDataSourceDefinition>;
@@ -47,8 +51,14 @@ export declare class PropertyEditorDatasourceComponent implements OnInit {
     }[]>;
     readonly availableParentFields: import("@angular/core").Signal<ReportComponentDefinition[]>;
     readonly staticOptions: import("@angular/core").Signal<StaticOptionItem[]>;
+    readonly procedureSelectOptions: import("@angular/core").Signal<SearchableSelectOption<any>[]>;
+    readonly tableSelectOptions: import("@angular/core").Signal<SearchableSelectOption<any>[]>;
+    readonly displayFieldSelectOptions: import("@angular/core").Signal<SearchableSelectOption<any>[]>;
+    readonly valueFieldSelectOptions: import("@angular/core").Signal<SearchableSelectOption<any>[]>;
+    readonly parentFieldSelectOptions: import("@angular/core").Signal<SearchableSelectOption<any>[]>;
     constructor();
     ngOnInit(): void;
+    ngOnDestroy(): void;
     loadEntities(): void;
     loadEntityDetails(entityName: string, type: DropdownSourceType): void;
     /**