bways-report 0.1.0

package/lib/core/registry/property-definition.model.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Property definitions for the Designer's property editor.
+ *
+ * Each registered component provides a `propertySchema` describing
+ * its configurable properties. The Designer's property editor uses
+ * this schema to dynamically generate an editing form — the property
+ * editor is itself metadata-driven.
+ */
+/**
+ * Describes a single configurable property of a component.
+ */
+export interface PropertyDefinition {
+    /** Property key (matches a key in `ReportComponentDefinition.properties`). */
+    key: string;
+    /** Display label in the property editor. */
+    label: string;
+    /** Property data type — determines which editor control is rendered. */
+    type: 'string' | 'number' | 'boolean' | 'select' | 'color' | 'datasource' | 'validation' | 'json';
+    /** Default value for new components. */
+    defaultValue?: unknown;
+    /** Options for `select` type properties. */
+    options?: PropertyOption[];
+    /** Whether this property is required. */
+    required?: boolean;
+    /** Grouping label for organizing properties in the editor. */
+    group?: string;
+    /** Help text / tooltip for the property editor. */
+    description?: string;
+}
+/**
+ * A single option for select-type properties.
+ */
+export interface PropertyOption {
+    /** Value stored in metadata. */
+    key: string;
+    /** Display label in the editor dropdown. */
+    label: string;
+}

package/lib/core/services/dynamic-form-builder.service.d.ts

@@ -0,0 +1,30 @@
+import { FormGroup } from '@angular/forms';
+import { ReportComponentDefinition } from '../models/report-component.model';
+import * as i0 from "@angular/core";
+/**
+ * DynamicFormBuilder converts metadata definitions into Angular Reactive Form controls.
+ *
+ * Follows the official Angular Dynamic Forms pattern:
+ * ReportComponentDefinition[] (metadata) -> DynamicFormBuilder -> FormGroup (runtime model)
+ */
+export declare class DynamicFormBuilder {
+    /**
+     * Constructs an Angular FormGroup from a list of component definitions.
+     *
+     * Only components with a valid `key` property generate form controls.
+     *
+     * @param components - Array of report component definitions.
+     * @param initialValues - Optional dictionary of initial control values by key.
+     * @returns Configured Angular FormGroup.
+     */
+    toFormGroup(components: ReportComponentDefinition[], initialValues?: Record<string, unknown>): FormGroup;
+    /**
+     * Extracts raw values from a FormGroup, including disabled controls.
+     *
+     * @param form - The FormGroup to extract from.
+     * @returns Key-value dictionary of all control values.
+     */
+    extractValues(form: FormGroup): Record<string, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormBuilder>;
+}

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

@@ -0,0 +1,3 @@
+export { DynamicFormBuilder } from './dynamic-form-builder.service';
+export { ReportSessionContextService } from './report-session-context.service';
+export type { SessionParamMatch, DerivedParametersResult, } from './report-session-context.service';

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

@@ -0,0 +1,87 @@
+import { OnDestroy, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import { SessionContextMap, SessionParamPrimitive } from '../tokens/session-context.token';
+import { ProcedureParameterMetadata } from '../../data-access/contracts/schema-discovery.contract';
+import * as i0 from "@angular/core";
+export interface SessionParamMatch {
+    isMatched: boolean;
+    sessionKey: string;
+    value: SessionParamPrimitive;
+    friendlyLabel: string;
+}
+export interface DerivedParametersResult {
+    /** The consolidated parameter payload for stored procedure execution */
+    parameters: Record<string, unknown>;
+    /** Map of which SP parameters were auto-derived from session context */
+    autoDerivedParams: Record<string, SessionParamMatch>;
+    /** Any required parameters that were neither in session context nor explicitly mapped */
+    unresolvedRequiredParams: ProcedureParameterMetadata[];
+}
+/**
+ * Service that manages host application session context parameters (e.g. branchId, companyId, userId)
+ * at runtime and automatically detects and binds them to Stored Procedure parameters.
+ *
+ * Designed to completely shield end users from entering technical session parameters while
+ * eliminating silent failures or thread crashes in host integrations.
+ */
+export declare class ReportSessionContextService implements OnDestroy {
+    private readonly rawSource;
+    private readonly sessionProvider;
+    /** Internal manual runtime session overrides (e.g. set via setSessionContext or setSessionParameter) */
+    private readonly manualRuntimeContext;
+    private readonly latestObservableValue;
+    private readonly providerObservableValue;
+    private observableSub?;
+    private providerSub?;
+    /**
+     * Reactive signal exposing the live session context parameters.
+     * Updates automatically when host app mutates runtime state, when observables emit,
+     * or when reactive signals update.
+     */
+    readonly sessionContext: Signal<SessionContextMap>;
+    /**
+     * Observable stream of live session parameters for RxJS-based integrations.
+     */
+    readonly sessionContext$: Observable<SessionContextMap>;
+    constructor();
+    ngOnDestroy(): void;
+    private initSubscriptions;
+    /**
+     * Sets or replaces the runtime session context.
+     * Can be called dynamically after user authentication, branch change, etc.
+     */
+    setSessionContext(context: SessionContextMap): void;
+    /**
+     * Updates or sets a specific session parameter at runtime (e.g. branchId = 2).
+     */
+    setSessionParameter(key: string, value: SessionParamPrimitive): void;
+    /**
+     * Clears any runtime session parameters set via `setSessionContext` or `setSessionParameter`.
+     */
+    clearSessionContext(): void;
+    /**
+     * Safely returns the current session context map.
+     * Always pulls the latest runtime state. Never throws or crashes the thread.
+     */
+    getCurrentSessionContext(): SessionContextMap;
+    /**
+     * Normalizes a parameter or session key into a lowercase alphanumeric string
+     * for reliable, case-insensitive, and symbol-insensitive matching.
+     * E.g. '@BranchId' -> 'branchid', 'branch_id' -> 'branchid', 'BranchID' -> 'branchid'
+     */
+    normalizeKey(key: string): string;
+    /**
+     * Checks whether a stored procedure parameter matches any key in the active session context.
+     * Supports exact, normalized, and common ERP synonyms.
+     */
+    matchParameter(paramName: string): SessionParamMatch | null;
+    /**
+     * Resolves and derives all stored procedure parameters:
+     * - Preserves explicit overrides (e.g. from canvas form controls or manual inputs)
+     * - Automatically injects matched session parameters
+     * - Validates whether required parameters are fulfilled
+     */
+    deriveParameters(spParams: ProcedureParameterMetadata[], explicitMappings?: Record<string, unknown>): DerivedParametersResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportSessionContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReportSessionContextService>;
+}

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

@@ -0,0 +1,4 @@
+export { REPORTING_CONFIG, GRID_COMPONENT, CHART_COMPONENT, } from './reporting-config.token';
+export type { ReportingConfig, } from './reporting-config.token';
+export { REPORT_SESSION_CONTEXT, REPORT_SESSION_PROVIDER, SessionContextProvider, } from './session-context.token';
+export type { SessionParamPrimitive, SessionContextMap, SessionContextProviderFn, SessionContextSource, } from './session-context.token';

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

@@ -0,0 +1,42 @@
+/**
+ * Reporting library configuration tokens.
+ *
+ * Core configuration models and injection tokens.
+ * Decoupled from UI primitives and data-access adapters.
+ */
+import { InjectionToken, Type } from '@angular/core';
+/**
+ * Library configuration options.
+ */
+export interface ReportingConfig {
+    /** Default page size for grids. */
+    defaultPageSize: number;
+    /** Date format string used across the library. */
+    dateFormat: string;
+    /** Whether the Designer feature is enabled. */
+    enableDesigner: boolean;
+    /** Current schema version for new reports. */
+    schemaVersion: number;
+    /** Base URL for backend reporting endpoints (NestJS / .NET / REST API). */
+    apiBaseUrl?: string;
+    /** Whether automatic backend schema discovery (SPs & Tables) is enabled. */
+    enableSchemaDiscovery?: boolean;
+}
+/**
+ * Injection token for the grid component.
+ *
+ * The host provides their grid component (BWays-grid, AG Grid wrapper, etc.)
+ * and the `ReportGridBridgeComponent` resolves it at runtime.
+ */
+export declare const GRID_COMPONENT: InjectionToken<Type<unknown>>;
+/**
+ * Injection token for the chart component.
+ *
+ * The host can provide their preferred chart component (Chart.js, Highcharts, ApexCharts wrapper, etc.)
+ * and the `ReportChartBridgeComponent` delegates rendering to it, or falls back to built-in SVG charts.
+ */
+export declare const CHART_COMPONENT: InjectionToken<Type<unknown>>;
+/**
+ * Injection token for the reporting library configuration.
+ */
+export declare const REPORTING_CONFIG: InjectionToken<ReportingConfig>;

package/lib/core/tokens/session-context.token.d.ts

@@ -0,0 +1,36 @@
+import { InjectionToken, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+/**
+ * Primitive types allowable as session parameter values.
+ */
+export type SessionParamPrimitive = string | number | boolean | null | undefined;
+/**
+ * Map of session parameters (e.g. { branchId: 1, companyId: 10, userId: 'usr-1' }).
+ */
+export type SessionContextMap = Record<string, SessionParamPrimitive>;
+/**
+ * Flexible session context provider source:
+ * - Plain object: `{ branchId: 1, companyId: 10 }`
+ * - Dynamic getter function: `() => authService.currentUserSession()`
+ * - Angular Signal: `authService.sessionSignal`
+ * - RxJS Observable: `authService.session$`
+ */
+export type SessionContextProviderFn = () => SessionContextMap | Signal<SessionContextMap> | Observable<SessionContextMap>;
+export type SessionContextSource = SessionContextMap | SessionContextProviderFn | Observable<SessionContextMap> | Signal<SessionContextMap>;
+/**
+ * Injection token for host application session parameters.
+ * When configuring `provideReporting({ sessionContext: ... })`, the host app
+ * supplies their current session context (e.g. branchId, companyId, userId, tenantId).
+ */
+export declare const REPORT_SESSION_CONTEXT: InjectionToken<SessionContextSource>;
+/**
+ * Service contract for host applications providing runtime session parameters.
+ * A host service (e.g. AuthService, SessionService) can implement this interface/class.
+ */
+export declare abstract class SessionContextProvider {
+    abstract getSessionContext(): SessionContextMap | Observable<SessionContextMap> | Signal<SessionContextMap> | Promise<SessionContextMap>;
+}
+/**
+ * Injection token for host application session provider service class.
+ */
+export declare const REPORT_SESSION_PROVIDER: InjectionToken<SessionContextProvider>;

package/lib/core/utilities/id-generator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates a unique identifier with a given prefix.
+ *
+ * Safe for modern browser and Node environments.
+ *
+ * @param prefix - Prefix for the ID (default 'cmp').
+ * @returns Unique string ID (e.g. 'cmp-4a7b2c9d').
+ */
+export declare function generateId(prefix?: string): string;

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

@@ -0,0 +1,3 @@
+export { generateId } from './id-generator';
+export { migrateDefinition } from './schema-migration';
+export type { MigrationFn } from './schema-migration';

package/lib/core/utilities/schema-migration.d.ts

@@ -0,0 +1,10 @@
+import { ReportDefinition } from '../models/report-definition.model';
+export type MigrationFn = (def: ReportDefinition) => ReportDefinition;
+/**
+ * Migrates a ReportDefinition to a target schema version.
+ *
+ * @param definition - Source report definition.
+ * @param targetVersion - Desired schema version (default current version = 1).
+ * @returns Migrated ReportDefinition.
+ */
+export declare function migrateDefinition(definition: ReportDefinition, targetVersion?: number): ReportDefinition;

package/lib/core/utils/identifier-humanizer.d.ts

@@ -0,0 +1,22 @@
+import { EntityColumnMetadata } from '../../data-access/contracts/schema-discovery.contract';
+/**
+ * Strips technical SQL prefixes (usp_, sp_, tbl_, vw_, @), removes schema if present,
+ * and converts snake_case, PascalCase, or camelCase into clean, human-readable Title Case.
+ *
+ * Examples:
+ * - 'dbo.usp_GetCustomerList' -> 'Customer List'
+ * - 'usp_GetBranches' -> 'Branches'
+ * - '@BranchId' -> 'Branch'
+ * - '@ActiveOnly' -> 'Active Only'
+ * - 'tbl_Products' -> 'Products'
+ * - 'customer_name_en' -> 'Customer Name En'
+ */
+export declare function humanizeIdentifier(raw: string): string;
+/**
+ * Detects the most probable column to use as the value/key (e.g. ID, Code, Key, Guid).
+ */
+export declare function detectDefaultValueField(columns: EntityColumnMetadata[]): string | undefined;
+/**
+ * Detects the most probable column to use as the display text (e.g. Name, Title, Label, Description).
+ */
+export declare function detectDefaultDisplayField(columns: EntityColumnMetadata[]): string | undefined;

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

@@ -0,0 +1 @@
+export { createValidators, getValidationMessage } from './validation-factory';

package/lib/core/validation/validation-factory.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Validation factory — converts `ValidationDefinition` metadata
+ * into Angular `ValidatorFn[]`.
+ *
+ * This is a **pure function** — no DI, no Angular TestBed needed.
+ * Easily unit-testable.
+ */
+import { ValidatorFn } from '@angular/forms';
+import { ValidationDefinition } from '../models/validation.model';
+/**
+ * Converts a `ValidationDefinition` into an array of Angular validator functions.
+ *
+ * @param definition - Validation metadata from the report definition.
+ * @returns Array of Angular `ValidatorFn` to apply to a form control.
+ *
+ * @example
+ * ```typescript
+ * const validators = createValidators({ required: true, maxLength: 100 });
+ * const control = new FormControl('', validators);
+ * ```
+ */
+export declare function createValidators(definition?: ValidationDefinition): ValidatorFn[];
+/**
+ * Extracts a user-facing validation error message from a validation definition
+ * and error key.
+ *
+ * @param definition - Validation metadata.
+ * @param errorKey - The validation error key (e.g., 'required', 'maxlength').
+ * @returns The custom message if defined, or a default message.
+ */
+export declare function getValidationMessage(definition: ValidationDefinition | undefined, errorKey: string): string;

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

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { LookupOptionItem, LookupQueryRequest, ReportLookupAdapter } from '../contracts/lookup.contract';
+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.
+ */
+export declare class HttpReportLookupAdapter extends ReportLookupAdapter {
+    private readonly http;
+    private readonly config;
+    private readonly cache;
+    private readonly mockDataStore;
+    fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]>;
+    private setCache;
+    private generateCacheKey;
+    private resolveMockOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpReportLookupAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpReportLookupAdapter>;
+}

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

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { DatabaseEntityMetadata, DatabaseEntityType, EntityColumnMetadata, ProcedureParameterMetadata, ReportSchemaDiscoveryAdapter } from '../contracts/schema-discovery.contract';
+import * as i0 from "@angular/core";
+/**
+ * Built-in HTTP adapter for backend database schema discovery.
+ * Connects to NestJS / REST backend endpoints, with fallback mock schema for development.
+ */
+export declare class HttpReportSchemaDiscoveryAdapter extends ReportSchemaDiscoveryAdapter {
+    private readonly http;
+    private readonly config;
+    private readonly mockEntities;
+    private readonly mockColumns;
+    private readonly mockParameters;
+    getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]>;
+    getColumns(entityName: string, schema?: string, type?: DatabaseEntityType): Observable<EntityColumnMetadata[]>;
+    getParameters(entityName: string, schema?: string): Observable<ProcedureParameterMetadata[]>;
+    private filterMockEntities;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpReportSchemaDiscoveryAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpReportSchemaDiscoveryAdapter>;
+}

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

@@ -0,0 +1,2 @@
+export { HttpReportSchemaDiscoveryAdapter } from './http-schema-discovery.adapter';
+export { HttpReportLookupAdapter } from './http-lookup.adapter';

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

@@ -0,0 +1,37 @@
+/**
+ * Data-access contracts — abstract classes the host application implements.
+ *
+ * The library defines WHAT data it needs; the host defines HOW to get it.
+ * This keeps the library host-independent.
+ */
+import { Observable } from 'rxjs';
+import { ReportDataSourceDefinition } from '../../core/models/report-datasource.model';
+/**
+ * Contract for executing report data source queries.
+ *
+ * The host application provides a concrete implementation that
+ * calls the appropriate backend (REST API, stored procedures, etc.).
+ *
+ * @example
+ * ```typescript
+ * // Host implementation
+ * @Injectable()
+ * export class MyDataSourceAdapter extends ReportDataSourceAdapter {
+ *   constructor(private http: HttpClient) { super(); }
+ *
+ *   execute(dataSource, parameters) {
+ *     return this.http.post(dataSource.endpoint, parameters);
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class ReportDataSourceAdapter {
+    /**
+     * Execute a data source query and return the result rows.
+     *
+     * @param dataSource - The data source definition from the report metadata.
+     * @param parameters - Current parameter values from the report form.
+     * @returns Observable of result rows.
+     */
+    abstract execute(dataSource: ReportDataSourceDefinition, parameters: Record<string, unknown>): Observable<unknown[]>;
+}

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

@@ -0,0 +1,9 @@
+export { ReportDataSourceAdapter } from './data-source.contract';
+export { MasterDataProvider } from './master-data.provider';
+export type { MasterDataOptions, MasterDataItem } from './master-data.provider';
+export { ReportPersistenceAdapter } from './report-persistence.contract';
+export { ReportTranslationAdapter } from './translation.contract';
+export { ReportSchemaDiscoveryAdapter } from './schema-discovery.contract';
+export type { DatabaseEntityType, DatabaseEntityMetadata, EntityColumnMetadata, ProcedureParameterMetadata, } from './schema-discovery.contract';
+export { ReportLookupAdapter } from './lookup.contract';
+export type { LookupQueryRequest, LookupOptionItem } from './lookup.contract';

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

@@ -0,0 +1,32 @@
+import { Observable } from 'rxjs';
+import { DropdownSourceType } from '../../core/models/report-component.model';
+/**
+ * Request payload for querying lookup data from the host backend
+ */
+export interface LookupQueryRequest {
+    sourceType: DropdownSourceType;
+    entityName?: string;
+    schema?: string;
+    valueField: string;
+    displayField: string;
+    filter?: Record<string, unknown>;
+    parameters?: Record<string, unknown>;
+    limit?: number;
+}
+/**
+ * Normalized option item for dropdowns and selectors
+ */
+export interface LookupOptionItem {
+    value: string | number;
+    label: string;
+    raw?: Record<string, unknown>;
+}
+/**
+ * Abstract contract for fetching dynamic lookup/option data for report dropdown components.
+ */
+export declare abstract class ReportLookupAdapter {
+    /**
+     * Fetches dropdown option rows from database table or stored procedure.
+     */
+    abstract fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]>;
+}

package/lib/data-access/contracts/master-data.provider.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Master data provider contract.
+ *
+ * Provides lookup/reference data for report components
+ * (e.g., dropdown options for customers, products, branches).
+ */
+import { Observable } from 'rxjs';
+/**
+ * Options for querying master data.
+ */
+export interface MasterDataOptions {
+    /** Search/filter text. */
+    searchText?: string;
+    /** Maximum number of items to return. */
+    limit?: number;
+    /** Additional filter parameters. */
+    filter?: Record<string, unknown>;
+}
+/**
+ * A single master data item.
+ */
+export interface MasterDataItem {
+    /** The value to store. */
+    value: unknown;
+    /** The display label. */
+    label: string;
+    /** Additional data fields. */
+    [key: string]: unknown;
+}
+/**
+ * Contract for providing master/lookup data to report components.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class MyMasterDataProvider extends MasterDataProvider {
+ *   constructor(private http: HttpClient) { super(); }
+ *
+ *   getMasterData(masterName, options) {
+ *     return this.http.get(`/api/master/${masterName}`, { params: options });
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class MasterDataProvider {
+    /**
+     * Fetch master data items by name.
+     *
+     * @param masterName - The master data set name (e.g., 'customers', 'products').
+     * @param options - Optional filtering/pagination.
+     * @returns Observable of master data items.
+     */
+    abstract getMasterData(masterName: string, options?: MasterDataOptions): Observable<MasterDataItem[]>;
+}

package/lib/data-access/contracts/report-persistence.contract.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Report persistence contract.
+ *
+ * The host application implements this to save/load report definitions
+ * to/from their backend (database, file system, API, etc.).
+ */
+import { Observable } from 'rxjs';
+import { ReportDefinition, ReportSummary } from '../../core/models/report-definition.model';
+/**
+ * Contract for persisting report definitions.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class MyPersistenceAdapter extends ReportPersistenceAdapter {
+ *   constructor(private http: HttpClient) { super(); }
+ *
+ *   load(reportId) {
+ *     return this.http.get<ReportDefinition>(`/api/reports/${reportId}`);
+ *   }
+ *   // ... other methods
+ * }
+ * ```
+ */
+export declare abstract class ReportPersistenceAdapter {
+    /** Load a full report definition by ID. */
+    abstract load(reportId: string): Observable<ReportDefinition>;
+    /** Save (create or update) a report definition. */
+    abstract save(report: ReportDefinition): Observable<ReportDefinition>;
+    /** List available reports (summaries only). */
+    abstract list(): Observable<ReportSummary[]>;
+    /** Delete a report by ID. */
+    abstract delete(reportId: string): Observable<void>;
+    /** Publish a specific version of a report. */
+    abstract publish(reportId: string, version: number): Observable<void>;
+}

package/lib/data-access/contracts/schema-discovery.contract.d.ts

@@ -0,0 +1,52 @@
+import { Observable } from 'rxjs';
+export type DatabaseEntityType = 'table' | 'view' | 'stored_procedure';
+/**
+ * Metadata for a database entity (table, view, or stored procedure)
+ */
+export interface DatabaseEntityMetadata {
+    name: string;
+    schema: string;
+    type: DatabaseEntityType;
+    friendlyName?: string;
+    category?: string;
+    description?: string;
+}
+/**
+ * Metadata for an entity column or stored procedure return field
+ */
+export interface EntityColumnMetadata {
+    field: string;
+    label: string;
+    dataType: 'string' | 'number' | 'date' | 'boolean';
+    nullable?: boolean;
+}
+/**
+ * Metadata for stored procedure parameters
+ */
+export interface ProcedureParameterMetadata {
+    name: string;
+    friendlyLabel?: string;
+    description?: string;
+    dataType: 'string' | 'number' | 'date' | 'boolean';
+    sqlType: string;
+    required: boolean;
+    defaultValue?: unknown;
+}
+/**
+ * Abstract contract for discovering backend database schemas, entities, columns, and parameters.
+ * Enables the Visual Designer to discover tables and procedures without tight coupling.
+ */
+export declare abstract class ReportSchemaDiscoveryAdapter {
+    /**
+     * Retrieves list of database tables, views, or stored procedures.
+     */
+    abstract getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]>;
+    /**
+     * Retrieves columns for a specific table, view, or stored procedure.
+     */
+    abstract getColumns(entityName: string, schema?: string, type?: DatabaseEntityType): Observable<EntityColumnMetadata[]>;
+    /**
+     * Retrieves parameters for a stored procedure.
+     */
+    abstract getParameters(entityName: string, schema?: string): Observable<ProcedureParameterMetadata[]>;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Translation adapter contract.
+ *
+ * Allows host ERP applications to plug in their own i18n/translation
+ * system (e.g. @ngx-translate, Transloco, or custom backend dictionary).
+ */
+export declare abstract class ReportTranslationAdapter {
+    /**
+     * Translate a given key into the current active language.
+     *
+     * @param key - Translation key or default label.
+     * @param params - Optional interpolation parameters.
+     * @returns Translated string, or key if no translation found.
+     */
+    abstract translate(key: string, params?: Record<string, string | number>): string;
+}

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

@@ -0,0 +1,2 @@
+export * from './contracts';
+export * from './adapters';