bways-report 0.1.8 → 0.2.0

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

@@ -8,6 +8,7 @@
  */
 import { Type } from '@angular/core';
 import { SessionContextProvider, SessionContextSource } from '../tokens/session-context.token';
+import { ReportApiEndpointDefinition } from '../models/report-api-endpoint.model';
 /**
  * Palette component category names the developer can use
  * when restricting the designer component palette.
@@ -46,18 +47,18 @@ export interface BwaysReportConfig {
      * GET endpoint returning the list of stored procedures with their parameters.
      * Response: `[{ name, schema, parameters: [{ name, sqlType, required, defaultValue? }] }]`
      */
-    spEndpoint: string;
+    spEndpoint?: string;
     /**
      * GET endpoint returning the list of tables/views with their columns.
      * Response: `[{ name, schema, type: 'table'|'view', columns: [{ name, sqlType }] }]`
      */
-    tablesEndpoint: string;
+    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;
+    executeEndpoint?: string;
     /**
      * Optional POST endpoint for fetching dropdown master data and lookup options.
      * Defaults to replacing `/execute` with `/lookup` if omitted.
@@ -65,13 +66,24 @@ export interface BwaysReportConfig {
     lookupEndpoint?: string;
     /**
      * Optional CRUD endpoint for saving/loading report page definitions.
-     * When omitted, reports are saved to browser localStorage with a console warning.
+     * When omitted, uses the reporting service base inferred from the configured endpoints.
+     * Defaults to /api/reporting/reports; the backend stores definitions in dbo.CNFREPORTDEF.
      * - GET    → list saved reports
      * - GET /:id → load a specific report
      * - POST   → save a new or updated report
      * - DELETE /:id → delete a report
      */
     reportsEndpoint?: string;
+    /**
+     * Optional GET endpoint returning the catalog of registered REST APIs.
+     * Response: ReportApiEndpointDefinition[]
+     */
+    apisEndpoint?: string;
+    /**
+     * Optional static/in-memory API endpoints registered directly in the host application.
+     * Merged with backend-discovered APIs in the Visual Designer.
+     */
+    apiEndpoints?: ReportApiEndpointDefinition[];
     /**
      * Component palette groups to show in the designer.
      * Defaults to all groups when not specified.
@@ -125,6 +137,10 @@ export interface BwaysReportConfig {
     dateFormat?: string;
     /** Timeout in ms for lookup/execute queries. @default 300000 */
     lookupTimeoutMs?: number;
+    /** Maximum duration of an execution request (defaults to lookupTimeoutMs). */
+    executionTimeoutMs?: number;
+    /** Exact HTTP(S) origins permitted to receive API credentials and custom headers. Same-origin is trusted by default. */
+    trustedApiOrigins?: string[];
 }
 /**
  * Result of normalizing a `BwaysReportConfig` for internal use.
@@ -136,6 +152,8 @@ export interface NormalizedBwaysConfig {
     executeEndpoint: string;
     lookupEndpoint: string | null;
     reportsEndpoint: string | null;
+    apisEndpoint: string | null;
+    apiEndpoints: ReportApiEndpointDefinition[];
     /** Resolved internal category IDs (e.g. ['input', 'action', 'display']) */
     allowedCategories: string[] | null;
     /** Whether auto-parameter binding is enabled */
@@ -153,9 +171,13 @@ export interface NormalizedBwaysConfig {
     defaultPageSize: number;
     dateFormat: string;
     lookupTimeoutMs: number;
+    /** Maximum duration of an execution request (defaults to lookupTimeoutMs). */
+    executionTimeoutMs?: number;
+    /** Exact HTTP(S) origins permitted to receive API credentials and custom headers. Same-origin is trusted by default. */
+    trustedApiOrigins?: string[];
 }
 /**
  * Normalizes a `BwaysReportConfig` into the internal format.
- * Validates required fields and maps friendly names to internal IDs.
+ * Validates supplied endpoints and maps friendly names to internal IDs.
  */
 export declare function normalizeBwaysConfig(config: BwaysReportConfig): NormalizedBwaysConfig;

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

@@ -2,7 +2,8 @@
  * Barrel export for all core domain models.
  */
 export type { ReportDefinition, ReportSummary, ReportPermissionDefinition, } from './report-definition.model';
-export type { ReportComponentDefinition, ComponentBindingDefinition, ComponentDataSourceDefinition, VisibilityDefinition, } from './report-component.model';
+export type { ReportComponentDefinition, ComponentBindingDefinition, ComponentDataSourceDefinition, DropdownSourceType, VisibilityDefinition, } from './report-component.model';
+export type { ReportApiEndpointDefinition, ReportApiParameterDefinition, } from './report-api-endpoint.model';
 export type { ReportParameterDefinition, } from './report-parameter.model';
 export type { ReportDataSourceDefinition, DataSourceCacheDefinition, } from './report-datasource.model';
 export type { ReportGridDefinition, GridColumnDefinition, GridOptionsDefinition, } from './report-grid.model';

package/lib/core/models/report-api-endpoint.model.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Definitions for API-based data retrieval endpoints.
+ *
+ * Enables reports and form components to consume REST / HTTP APIs
+ * with parameter interpolation, custom headers, and data path resolution.
+ */
+export interface ReportApiParameterDefinition {
+    name: string;
+    label?: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'array';
+    in: 'query' | 'path' | 'body' | 'header';
+    required?: boolean;
+    defaultValue?: unknown;
+    description?: string;
+}
+export interface ReportApiEndpointDefinition {
+    id: string;
+    name: string;
+    url?: string;
+    endpoint?: string;
+    method?: 'GET' | 'POST' | 'PUT';
+    description?: string;
+    category?: string;
+    dataPath?: string;
+    totalPath?: string;
+    parameters?: ReportApiParameterDefinition[];
+    headers?: Record<string, string>;
+    responseSample?: Record<string, unknown>[];
+    useProxy?: boolean;
+}

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

@@ -20,13 +20,13 @@ export interface ComponentBindingDefinition {
     /** The parameter key this component writes to (for input components). */
     parameterKey?: string;
 }
-export type DropdownSourceType = 'static' | 'table' | 'procedure' | 'master';
+export type DropdownSourceType = 'static' | 'table' | 'procedure' | 'master' | 'api';
 /**
  * Data source configuration for components that load their own data
- * (e.g., dropdowns loading options from database tables, stored procedures, or master data).
+ * (e.g., dropdowns loading options from database tables, stored procedures, master data, or REST APIs).
  */
 export interface ComponentDataSourceDefinition {
-    /** Source type: 'static' | 'table' | 'procedure' | 'master' */
+    /** Source type: 'static' | 'table' | 'procedure' | 'master' | 'api' */
     sourceType?: DropdownSourceType;
     /** Database schema, e.g. 'dbo' (defaults to 'dbo'). */
     schema?: string;
@@ -40,12 +40,24 @@ export interface ComponentDataSourceDefinition {
     valueField?: string;
     /** Optional static filter parameters (e.g. { isActive: 1 }). */
     filter?: Record<string, unknown>;
-    /** Stored procedure parameter mappings (e.g. { '@BranchId': '{{branchSelect}}', '@ActiveOnly': true }). */
+    /** Parameter mappings (e.g. { '@BranchId': '{{branchSelect}}', '@ActiveOnly': true }). */
     parameterMappings?: Record<string, string | number | boolean>;
     /** Keys of other form components whose values this data source depends on (for Cascading Dropdowns). */
     dependsOn?: string[];
     /** Cache time-to-live in seconds (default 300s). */
     cacheTtl?: number;
+    /** Registered API endpoint ID or raw URL path (e.g. 'api-customers' or '/api/v1/customers') */
+    apiEndpoint?: string;
+    /** HTTP method to use (defaults to 'GET') */
+    apiMethod?: 'GET' | 'POST';
+    /** Dot-notation path to the array of items in the response JSON (e.g. 'data.items' or 'rows') */
+    dataPath?: string;
+    /** Custom query parameters or payload mappings for the API request */
+    apiParams?: Record<string, unknown>;
+    /** Optional custom headers (e.g. { 'X-Custom-Tenant': '{{session.tenantId}}' }) */
+    apiHeaders?: Record<string, string>;
+    /** Whether request should be proxied via backend reporting gateway */
+    useProxy?: boolean;
 }
 /**
  * Controls when a component is visible based on other component values.

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

@@ -19,10 +19,15 @@ export interface ReportDataSourceDefinition {
     method?: 'GET' | 'POST' | 'STORED_PROCEDURE' | 'CUSTOM';
     /** Database schema (defaults to 'dbo'). */
     schema?: string;
+    /** Optional table/view column projection and maximum result rows. */
+    columns?: string[];
+    top?: number;
+    /** Explicit table equality filters. Values can reference form/session tokens. */
+    filter?: Record<string, string | number | boolean>;
     /** Backend execution type. */
-    type?: 'stored_procedure' | 'table' | 'view' | 'sql' | string;
+    type?: 'stored_procedure' | 'table' | 'view' | 'sql' | 'api' | string;
     /**
-     * Stored procedure parameter mappings. Values may be fixed, or tokens:
+     * Parameter mappings. Values may be fixed, or tokens:
      * `{{session.branchId}}`, `{{context.today}}`, `{{fieldKey}}` (canvas field).
      */
     parameterMappings?: Record<string, string | number | boolean>;
@@ -36,6 +41,20 @@ export interface ReportDataSourceDefinition {
     autoExecute?: boolean;
     /** Caching strategy. */
     cache?: DataSourceCacheDefinition;
+    /** Base URL override (if calling an external service outside apiBaseUrl) */
+    baseUrl?: string;
+    /** Dot-notation path to the array of records in the response (e.g. 'data.items' or 'rows') */
+    dataPath?: string;
+    /** Dot-notation path to total count for server-side pagination (e.g. 'result.total') */
+    totalPath?: string;
+    /** Parameter placement: 'query' | 'body' | 'auto' */
+    paramPlacement?: 'query' | 'body' | 'auto';
+    /** Request body template for POST requests */
+    bodyTemplate?: Record<string, unknown>;
+    /** Custom HTTP headers to include with the API request */
+    headers?: Record<string, string>;
+    /** Whether to route through the backend proxy gateway */
+    useProxy?: boolean;
 }
 /**
  * Caching configuration for a data source.

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

@@ -3,3 +3,4 @@ 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';
+export { ReportApiExecutionService } from './report-api-execution.service';

package/lib/core/services/report-api-execution.service.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { ReportApiEndpointDefinition } from '../models/report-api-endpoint.model';
+import * as i0 from "@angular/core";
+export interface ApiExecutionOptions {
+    url?: string;
+    endpoint?: string;
+    method?: string;
+    dataPath?: string;
+    totalPath?: string;
+    headers?: Record<string, string>;
+    useProxy?: boolean;
+    bodyTemplate?: Record<string, unknown>;
+}
+/**
+ * Service responsible for executing API-based data retrieval requests.
+ *
+ * Supports URL path parameter interpolation (:id, {{id}}), query string parameter
+ * placement, JSON payload mapping, session header substitution, proxy routing,
+ * and dot-path response data extraction.
+ */
+export declare class ReportApiExecutionService {
+    private readonly http;
+    private readonly session;
+    private readonly reportingConfig;
+    private readonly endpoints;
+    getRegisteredEndpoints(): ReportApiEndpointDefinition[];
+    /**
+     * Executes a parameterized REST API request and extracts the result array.
+     *
+     * @param options Target endpoint configuration, URL, method, and data path.
+     * @param formValues Active parameter and filter values from the form/context.
+     * @param customMappings Additional fixed or mapped parameter values.
+     */
+    executeApi(options: ApiExecutionOptions | Partial<ReportApiEndpointDefinition>, formValues?: Record<string, unknown>, customMappings?: Record<string, unknown>): Observable<unknown[]>;
+    /**
+     * Dot-notation extractor: 'data.items' -> response.data.items
+     */
+    extractDataArray(response: any, dataPath?: string): unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportApiExecutionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReportApiExecutionService>;
+}

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

@@ -16,6 +16,7 @@ export declare class ReportDataDiscoveryService {
     private readonly discoveryAdapter;
     private readonly lookupAdapter;
     private readonly sessionService;
+    private readonly apiExecutionService;
     /**
      * Retrieves all database tables, views, and stored procedures.
      */
@@ -29,8 +30,29 @@ export declare class ReportDataDiscoveryService {
      * 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.
+     * 3. For REST APIs, executes a dynamic test sample and extracts columns from the result array.
      */
-    autoDetectColumns(entityName: string, entityType?: 'table' | 'stored_procedure', mappings?: Record<string, unknown>, schema?: string): Observable<GridColumnDefinition[]>;
+    autoDetectColumns(entityName: string, entityType?: 'table' | 'stored_procedure' | 'api', mappings?: Record<string, unknown>, schema?: string, apiOptions?: {
+        dataPath?: string;
+        method?: string;
+        headers?: Record<string, string>;
+        useProxy?: boolean;
+    }): Observable<GridColumnDefinition[]>;
+    /**
+     * Executes a sample API call and infers grid column definitions from the response records.
+     */
+    autoDetectApiColumns(urlOrOptions: string | {
+        endpoint?: string;
+        url?: string;
+        method?: string;
+        dataPath?: string;
+        headers?: Record<string, string>;
+        useProxy?: boolean;
+    }, dataPathOrParams?: string | Record<string, unknown>, params?: Record<string, unknown>, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        useProxy?: boolean;
+    }): Observable<GridColumnDefinition[]>;
     private mapStaticColumnsToGrid;
     private fallbackDynamicDetection;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReportDataDiscoveryService, never>;

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

@@ -1,3 +1,4 @@
+import { BwaysReportConfig } from '../config/bways-report-config';
 import { OnDestroy, Signal } from '@angular/core';
 import { Observable } from 'rxjs';
 import { SessionContextMap, SessionParamPrimitive } from '../tokens/session-context.token';
@@ -25,6 +26,12 @@ export interface DerivedParametersResult {
  * eliminating silent failures or thread crashes in host integrations.
  */
 export declare class ReportSessionContextService implements OnDestroy {
+    private readonly injector;
+    private readonly inheritedSession;
+    private readonly localReader;
+    private readonly localAsync;
+    private localCleanup?;
+    private configuredSource;
     private readonly rawSource;
     private readonly sessionProvider;
     private readonly reportingConfig;
@@ -46,6 +53,8 @@ export declare class ReportSessionContextService implements OnDestroy {
     readonly sessionContext$: Observable<SessionContextMap>;
     constructor();
     ngOnDestroy(): void;
+    /** Internal: changes only the session owned by an embedded designer. */
+    configureDesignerSession(config: BwaysReportConfig | null | undefined): void;
     private initSubscriptions;
     /**
      * Sets or replaces the runtime session context.

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

@@ -0,0 +1,4 @@
+import { InjectionToken, Signal } from '@angular/core';
+import { BwaysReportConfig } from '../config/bways-report-config';
+/** Internal reactive configuration owned by one embedded designer. */
+export declare const DESIGNER_LOCAL_CONFIG: InjectionToken<Signal<BwaysReportConfig | null>>;

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

@@ -23,6 +23,10 @@ export interface ReportingConfig {
     enableSchemaDiscovery?: boolean;
     /** Optional timeout in milliseconds for dropdown lookup queries (defaults to 300000ms / 5 minutes). */
     lookupTimeoutMs?: number;
+    /** Maximum duration of an execution request (defaults to lookupTimeoutMs). */
+    executionTimeoutMs?: number;
+    /** Exact HTTP(S) origins permitted to receive API credentials and custom headers. Same-origin is trusted by default. */
+    trustedApiOrigins?: string[];
     /**
      * Internal category IDs to show in the designer palette.
      * When null/undefined, all categories are shown.

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

@@ -0,0 +1,12 @@
+interface ReportingEndpointSource {
+    reportsEndpoint?: string | null;
+    apiBaseUrl?: string | null;
+    executeEndpoint?: string | null;
+    spEndpoint?: string | null;
+    tablesEndpoint?: string | null;
+    lookupEndpoint?: string | null;
+    apisEndpoint?: string | null;
+}
+/** Built-in report storage uses the same reporting service; no separate save URL is required. */
+export declare function resolveReportsEndpoint(source: ReportingEndpointSource): string;
+export {};

package/lib/core/utils/report-request-scope.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+/** One owner per component. Replacing a channel cancels its previous request. */
+export declare class ReportRequestScope {
+    private readonly session;
+    private readonly endpoints;
+    private readonly config;
+    private readonly active;
+    constructor();
+    context(): string;
+    cancel(channel: string, settle?: boolean): void;
+    isActive(channel: string): boolean;
+    cancelAll(): void;
+    run<T>(channel: string, factory: () => Observable<T>, next: (value: T) => void, error: (error: Error) => void, settled?: () => void): void;
+}

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

@@ -6,8 +6,10 @@ export declare class EndpointDataSourceAdapter extends ReportDataSourceAdapter {
     private readonly http;
     private readonly endpoints;
     private readonly sessionService;
+    private readonly apiExecutionService;
     execute(dataSource: ReportDataSourceDefinition, parameters: Record<string, unknown>): Observable<unknown[]>;
     private resolveKind;
+    private isApiSource;
     static ɵfac: i0.ɵɵFactoryDeclaration<EndpointDataSourceAdapter, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EndpointDataSourceAdapter>;
 }

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

@@ -5,6 +5,7 @@ export declare class EndpointLookupAdapter extends ReportLookupAdapter {
     private readonly http;
     private readonly endpoints;
     private readonly sessionService;
+    private readonly apiExecutionService;
     private readonly cache;
     private readonly inFlight;
     fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]>;

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

@@ -1,12 +1,16 @@
 import { Observable } from 'rxjs';
 import { ReportDefinition, ReportSummary } from '../../core/models/report-definition.model';
-import { ReportPersistenceAdapter } from '../contracts/report-persistence.contract';
+import { ReportPersistenceAdapter, ReportSaveOptions, ReportIdStatus } from '../contracts/report-persistence.contract';
 import * as i0 from "@angular/core";
 export declare class EndpointPersistenceAdapter extends ReportPersistenceAdapter {
+    private readonly session;
+    private get headers();
     private readonly http;
     private readonly endpoints;
+    checkId(reportId: string): Observable<boolean>;
+    inspectId(reportId: string): Observable<ReportIdStatus>;
     load(reportId: string): Observable<ReportDefinition>;
-    save(report: ReportDefinition): Observable<ReportDefinition>;
+    save(report: ReportDefinition, options?: ReportSaveOptions): Observable<ReportDefinition>;
     list(): Observable<ReportSummary[]>;
     delete(reportId: string): Observable<void>;
     publish(reportId: string, version: number): Observable<void>;

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

@@ -7,8 +7,10 @@ export declare class EndpointSchemaDiscoveryAdapter extends ReportSchemaDiscover
     /** Cached list responses so we don't re-fetch on every getColumns/getParameters call */
     private spCache$;
     private tableCache$;
-    private spItems;
-    private tableItems;
+    private readonly session;
+    private spCacheKey;
+    private tableCacheKey;
+    private context;
     getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]>;
     getColumns(entityName: string, schema?: string, type?: DatabaseEntityType): Observable<EntityColumnMetadata[]>;
     getParameters(entityName: string, schema?: string): Observable<ProcedureParameterMetadata[]>;

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

@@ -5,6 +5,7 @@
  * are populated with the endpoint URLs so adapters can inject them.
  */
 import { InjectionToken } from '@angular/core';
+import { ReportApiEndpointDefinition } from '../../core/models/report-api-endpoint.model';
 /**
  * Endpoint URLs used by the endpoint-based adapters.
  */
@@ -14,7 +15,13 @@ export interface BwaysReportEndpoints {
     executeEndpoint: string;
     lookupEndpoint?: string | null;
     reportsEndpoint: string | null;
+    apisEndpoint?: string | null;
+    apiEndpoints?: ReportApiEndpointDefinition[];
 }
+/** Per-designer URL overrides. Omitted/undefined properties inherit app defaults. */
+export type BwaysReportApiUrls = {
+    [Key in 'spEndpoint' | 'tablesEndpoint' | 'executeEndpoint' | 'lookupEndpoint' | 'reportsEndpoint' | 'apisEndpoint']?: string;
+};
 /**
  * Injection token for the endpoint URLs.
  */

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

@@ -5,16 +5,14 @@ import * as i0 from "@angular/core";
 /**
  * Built-in HTTP adapter for executing report data sources against the reporting backend.
  * Automatically injects active multi-tenant session headers (X-Company-Id, X-Branch-Id)
- * and includes rich development fallback data when the backend is unreachable.
+ * and propagates execution errors to the caller.
  */
 export declare class HttpReportDataSourceAdapter extends ReportDataSourceAdapter {
     private readonly http;
     private readonly config;
     private readonly sessionService;
     execute(dataSource: ReportDataSourceDefinition, parameters: Record<string, unknown>): Observable<unknown[]>;
-    private getMockExecutionData;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpReportDataSourceAdapter, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HttpReportDataSourceAdapter>;
 }
-/** Convenience alias */
 export declare const HttpDataSourceAdapter: typeof HttpReportDataSourceAdapter;

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

@@ -2,20 +2,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, in-flight request deduplication, and fallback mock data.
+ * Built-in HTTP adapter for fetching dropdown options from backend database tables, SPs, and REST APIs.
+ * Includes in-memory caching with TTL, in-flight request deduplication, and explicit request errors.
  */
 export declare class HttpReportLookupAdapter extends ReportLookupAdapter {
     private readonly http;
     private readonly config;
     private readonly sessionService;
+    private readonly apiExecutionService;
     private readonly cache;
     private readonly inFlight;
-    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-persistence.adapter.d.ts

@@ -1,27 +1,22 @@
 import { Observable } from 'rxjs';
 import { ReportDefinition, ReportSummary } from '../../core/models/report-definition.model';
-import { ReportPersistenceAdapter } from '../contracts/report-persistence.contract';
+import { ReportPersistenceAdapter, ReportSaveOptions, ReportIdStatus } from '../contracts/report-persistence.contract';
 import * as i0 from "@angular/core";
-/**
- * Built-in HTTP adapter for report definitions persistence.
- * Connects to NestJS `/api/reporting/reports` endpoints.
- * Includes in-memory mock fallback when the remote backend is unreachable.
- */
+/** HTTP-only persistence. Use withLocalStorage() explicitly for offline demos. */
 export declare class HttpReportPersistenceAdapter extends ReportPersistenceAdapter {
+    private readonly session;
+    private get headers();
     private readonly http;
     private readonly config;
-    private readonly mockStore;
-    constructor();
-    load(reportId: string): Observable<ReportDefinition>;
-    save(report: ReportDefinition): Observable<ReportDefinition>;
+    checkId(reportId: string): Observable<boolean>;
+    inspectId(reportId: string): Observable<ReportIdStatus>;
+    load(id: string): Observable<ReportDefinition>;
+    save(report: ReportDefinition, options?: ReportSaveOptions): Observable<ReportDefinition>;
     list(): Observable<ReportSummary[]>;
-    delete(reportId: string): Observable<void>;
-    publish(reportId: string, version: number): Observable<void>;
-    private getMockReport;
-    private getMockSummaries;
-    private seedDefaultMockReports;
+    delete(id: string): Observable<void>;
+    publish(id: string, version: number): Observable<void>;
+    private request;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpReportPersistenceAdapter, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HttpReportPersistenceAdapter>;
 }
-/** Convenience alias */
 export declare const HttpPersistenceAdapter: typeof HttpReportPersistenceAdapter;

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

@@ -3,18 +3,16 @@ import { DatabaseEntityMetadata, DatabaseEntityType, EntityColumnMetadata, Proce
 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.
+ * Connects to NestJS / REST backend endpoints, without fabricating metadata when requests fail.
  */
 export declare class HttpReportSchemaDiscoveryAdapter extends ReportSchemaDiscoveryAdapter {
+    private readonly session;
+    private get headers();
     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

@@ -11,4 +11,4 @@ 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';
+export type { BwaysReportEndpoints, BwaysReportApiUrls } from './endpoint-tokens';

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

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { ReportPersistenceAdapter } from '../contracts/report-persistence.contract';
+import { ReportPersistenceAdapter, ReportSaveOptions } from '../contracts/report-persistence.contract';
 import { ReportDefinition, ReportSummary } from '../../core/models/report-definition.model';
 import * as i0 from "@angular/core";
 export declare class LocalStorageReportPersistenceAdapter extends ReportPersistenceAdapter {
@@ -11,7 +11,7 @@ export declare class LocalStorageReportPersistenceAdapter extends ReportPersiste
     private saveIndex;
     private saveDirect;
     load(reportId: string): Observable<ReportDefinition>;
-    save(report: ReportDefinition): Observable<ReportDefinition>;
+    save(report: ReportDefinition, options?: ReportSaveOptions): Observable<ReportDefinition>;
     list(): Observable<ReportSummary[]>;
     delete(reportId: string): Observable<void>;
     publish(reportId: string, version: number): Observable<void>;

package/lib/data-access/adapters/report-id-availability.d.ts

@@ -0,0 +1,6 @@
+import { ReportIdStatus } from '../contracts/report-persistence.contract';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+export declare function reportIdAvailability(http: HttpClient, url: string, headers: HttpHeaders, fallback: () => Observable<boolean>): Observable<boolean>;
+/** Version/name are optional for compatibility with earlier availability endpoints. */
+export declare function reportIdInspection(http: HttpClient, url: string, headers: HttpHeaders, fallback: () => Observable<ReportIdStatus>): Observable<ReportIdStatus>;

package/lib/data-access/adapters/session-headers.d.ts

@@ -0,0 +1,3 @@
+import { HttpHeaders } from '@angular/common/http';
+/** Authentication stays with host interceptors; reporting forwards tenant context. */
+export declare function reportSessionHeaders(session: Record<string, unknown>): HttpHeaders;

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

@@ -1,6 +1,7 @@
 export { ReportDataSourceAdapter } from './data-source.contract';
 export { MasterDataProvider } from './master-data.provider';
 export type { MasterDataOptions, MasterDataItem } from './master-data.provider';
+export type { ReportSaveOptions, ReportIdStatus } from './report-persistence.contract';
 export { ReportPersistenceAdapter } from './report-persistence.contract';
 export { ReportTranslationAdapter } from './translation.contract';
 export { ReportSchemaDiscoveryAdapter } from './schema-discovery.contract';

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

@@ -12,6 +12,9 @@ export interface LookupQueryRequest {
     filter?: Record<string, unknown>;
     parameters?: Record<string, unknown>;
     limit?: number;
+    apiEndpoint?: string;
+    dataPath?: string;
+    useProxy?: boolean;
 }
 /**
  * Normalized option item for dropdowns and selectors