@smartbit4all/ng-client 5.0.21 → 6.0.1

package/lib/session/api/model/accountInfo.d.ts

@@ -19,4 +19,6 @@ export interface AccountInfo {
     parameters?: {
         [key: string]: string;
     };
+    twoFA?: boolean;
+    twoFAMessage?: string;
 }

package/lib/session/projects.d.ts

@@ -4,3 +4,6 @@ export * from './smart-session.module';
 export * from './smart-session-handler.service';
 export * from './smart-timer/smart-session-timer.component';
 export * from './smart-timer/smart-session-timer.service';
+export * from './smart-backend-bootstrap.service';
+export * from './smart-backend-bootstrap.config';
+export * from './smart-default-error-ui.service';

package/lib/session/smart-backend-bootstrap.config.d.ts

@@ -0,0 +1,65 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { UiActionDescriptor } from '../view-context/api';
+import { SmartViewHandlerModel } from '../view-context/smart-view-context.model';
+import { SessionError } from './smart-session-handler.service';
+/**
+ * Externally provided session + viewContext to hydrate the bootstrap with,
+ * bypassing the regular `start()` flow. Typical use case: a native mobile
+ * shell that performed authentication itself and hands off the result to a
+ * webview-hosted Angular app via URL fragment.
+ */
+export interface SmartBackendBootstrapCredentials {
+    /** SID issued by the backend; will be sent as `Authorization: Bearer <sessionToken>`. */
+    sessionToken: string;
+    /** UUID of an already-existing viewContext on the backend. */
+    viewContextUuid: string;
+    /**
+     * Optional long-lived refresh token paired with the SID. If provided, it is
+     * persisted to localStorage so the autonomous `SmartErrorCatchingInterceptor`
+     * REFRESH flow can recover from `session.expired` errors without dropping
+     * the user back to a fresh anonymous session.
+     */
+    refreshToken?: string;
+}
+export interface SmartBackendBootstrapConfig {
+    url: string;
+    cookieName: string;
+    /**
+     * View name the backend uses for generic message dialogs. Defaults to
+     * `'message-dialog'` (the platform convention) when omitted.
+     */
+    messageDialogName?: string;
+    viewHandlers: SmartViewHandlerModel[];
+    actionDescriptors: Map<string, UiActionDescriptor>;
+    /** Optional override for the default `handleSessionError` flow. */
+    onSessionError?: (err: SessionError) => Promise<void> | void;
+    /** Optional override for the default `openSmartLink` handler. */
+    onSmartLink?: (channel: string) => Promise<void> | void;
+    /** Hook for host UX when `start()` rejects (snackbar + retry). */
+    onStartError?: (err: unknown) => Promise<void> | void;
+    /**
+     * Hook called when a BFF call fails at the transport level — server
+     * unreachable (status 0), gateway/service-unavailable (502/503/504), or
+     * generic server-error (500). Default: a console.warn line; the request
+     * still rejects with the original error, allowing per-call handling.
+     *
+     * Fire-and-forget: every failed request invokes the hook (no dedup); the
+     * host is responsible for own UI deduplication if needed (e.g. snackbar
+     * with a "this message is already showing" guard).
+     */
+    onTransportError?: (err: HttpErrorResponse) => Promise<void> | void;
+    /**
+     * Hook called when the backend reports the current viewContext is gone
+     * (logout, session expiry, backend restart) — i.e. when the
+     * `SmartErrorCatchingInterceptor` would historically auto-trigger
+     * `RESTART_VIEWCONTEXT`.
+     *
+     * Default: rebuilds a fresh anonymous viewContext via
+     * `viewContext.initNewViewContext()` (the historical web flow).
+     *
+     * Mobile/embedded hosts override this to fully delegate to the shell —
+     * typically by calling a JS bridge that signals the native side to
+     * tear down the webview and return to the native login page.
+     */
+    onViewContextLost?: (err: SessionError) => Promise<void> | void;
+}

package/lib/session/smart-backend-bootstrap.service.d.ts

@@ -0,0 +1,55 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { SmartSessionService } from './smart-session.service';
+import { SmartViewContextService } from '../view-context/smart-view-context.service';
+import { SessionError, SmartSessionHandlerService } from './smart-session-handler.service';
+import { SmartBackendBootstrapConfig, SmartBackendBootstrapCredentials } from './smart-backend-bootstrap.config';
+import * as i0 from "@angular/core";
+/**
+ * Thrown by `whenReady()` when the viewcontext was rebuilt between the
+ * caller's entry into `whenReady()` and the gate releasing. Any uuid the
+ * caller resolved before entering is now stale; `SmartComponentApiClient.run()`
+ * catches this and skips the load — the component is expected to receive a
+ * fresh uuid through `uuidOfPageHasBeenChanged` (NORMAL views) or to be
+ * recreated by `openView` (EMBEDDED/DIALOG views).
+ */
+export declare class ViewContextRebuiltError extends Error {
+    constructor();
+}
+export declare class SmartBackendBootstrapService implements SmartSessionHandlerService {
+    private session;
+    private viewContext;
+    private config?;
+    private runningInit?;
+    private lastInitFailed;
+    private mode?;
+    private runningViewContextLost?;
+    private runningSessionError?;
+    constructor(session: SmartSessionService, viewContext: SmartViewContextService);
+    configure(config: SmartBackendBootstrapConfig): void;
+    private handleSmartLink;
+    start(): Promise<void>;
+    bootstrapWith(creds: SmartBackendBootstrapCredentials): Promise<void>;
+    whenReady(): Promise<void>;
+    reset(): Promise<void>;
+    /**
+     * Called by `SmartErrorCatchingInterceptor` when the backend reports
+     * `session.viewcontext.missing`. Idempotent across concurrent and
+     * sequential calls until the next `reset()` — multiple racing BFF
+     * failures collapse into a single recovery attempt.
+     */
+    handleViewContextLost(err: SessionError): Promise<void>;
+    private runViewContextLost;
+    /**
+     * Called by `SmartErrorCatchingInterceptor` for transport-level failures
+     * (status 0, 5xx). Fire-and-forget; the request still rejects with the
+     * original error so callers can do per-call handling.
+     */
+    handleTransportError(err: HttpErrorResponse): Promise<void>;
+    private runInit;
+    private runBootstrapWith;
+    private handleInitFailure;
+    handleSessionError(err: SessionError): Promise<void>;
+    private runSessionError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartBackendBootstrapService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartBackendBootstrapService>;
+}

package/lib/session/smart-default-error-ui.service.d.ts

@@ -0,0 +1,90 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { SessionError } from './smart-session-handler.service';
+import * as i0 from "@angular/core";
+export type DefaultErrorUiLanguage = 'hu' | 'en' | 'auto';
+export interface DefaultErrorUiStrings {
+    startErrorMessage: string;
+    startErrorRetry: string;
+    transportErrorMessage: string;
+    transportErrorReload: string;
+    sessionErrorMessage: string;
+    sessionErrorAction: string;
+}
+export interface DefaultErrorUiOptions {
+    /** 'auto' (default) picks 'hu' if navigator.language starts with 'hu', else 'en'. */
+    language?: DefaultErrorUiLanguage;
+    /** Override individual strings; missing keys fall back to the language default. */
+    strings?: Partial<DefaultErrorUiStrings>;
+    /**
+     * Snackbar auto-dismiss in ms for transportError. Default: 0 (sticky).
+     *
+     * Sticky default rationale: a transport error commonly leaves the screen in
+     * an inconsistent state (failed component loads, stuck spinners) that does
+     * NOT self-recover when the server returns. An auto-dismissing snackbar
+     * would hide the notification before the user can act, leaving them with a
+     * broken UI and no way back. Sticky forces the Reload action.
+     *
+     * Set a positive number to opt into auto-dismiss (e.g. mobile-shell flows
+     * where the shell tears down the webview on transport error anyway).
+     *
+     * `startError` is always sticky regardless — the app is unusable until the
+     * user retries.
+     */
+    transportErrorDuration?: number;
+}
+/**
+ * Opt-in default UX for `SmartBackendBootstrapService` error hooks.
+ *
+ * Spread the result of `hooks(options)` into `bootstrap.configure()` to get a
+ * MatSnackBar-based "error + retry" UI without writing the host glue:
+ *
+ * ```ts
+ * bootstrap.configure({
+ *   ...minimalConfig,
+ *   ...defaultErrorUi.hooks({ language: 'hu' }),
+ * });
+ * ```
+ *
+ * Hosts that want custom logic can omit this service and write their own
+ * `onStartError` / `onTransportError` callbacks directly.
+ */
+export declare class SmartDefaultErrorUiService {
+    private snackBar;
+    private session;
+    /** Returns a hooks bundle ready to spread into `bootstrap.configure()`. */
+    hooks(options?: DefaultErrorUiOptions): {
+        onStartError: (err: unknown) => void;
+        onTransportError: (err: HttpErrorResponse) => void;
+        onSessionError: (err: SessionError) => void;
+    };
+    showStartError(_err: unknown, options?: DefaultErrorUiOptions): void;
+    showTransportError(_err: HttpErrorResponse, options?: DefaultErrorUiOptions): void;
+    showSessionError(_err: SessionError, options?: DefaultErrorUiOptions): void;
+    /**
+     * Clears the dead session and reloads. Unlike `verifyServerAndReload`, this
+     * does NOT pre-check via `getSession()` — the SID is known to be invalid,
+     * so the check would fail. We best-effort `clearAndStartNewSession()`
+     * (creates a fresh anonymous session); reload happens regardless so the
+     * user is not stuck if the clear fails (e.g., server flapping).
+     *
+     * Overridable in tests.
+     */
+    protected recoverSession(): Promise<void>;
+    /**
+     * Pings `getSession()` before reloading: if the server is still down, the
+     * reload would just re-trigger the broken-screen state. The failed check
+     * goes through `SmartErrorCatchingInterceptor` and re-fires `onTransportError`,
+     * so the user sees a fresh snackbar — they get visible feedback that the
+     * server is still unreachable, without paying the cost of a full bundle
+     * reload that lands on the same broken state.
+     *
+     * Overridable in tests.
+     */
+    protected verifyServerAndReload(): Promise<void>;
+    /** Overridable in tests. */
+    protected reloadPage(): void;
+    private resolveStrings;
+    private resolveLanguage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartDefaultErrorUiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartDefaultErrorUiService>;
+}

package/lib/session/smart-error-catching.interceptor.d.ts

@@ -1,14 +1,17 @@
 import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { SessionError, SmartSessionService } from './projects';
+import { SmartBackendBootstrapService } from './smart-backend-bootstrap.service';
 import * as i0 from "@angular/core";
 export declare class SmartErrorCatchingInterceptor implements HttpInterceptor {
     private session;
+    private bootstrap;
     sessionErrorCodes: SessionError[];
-    constructor(session: SmartSessionService);
+    constructor(session: SmartSessionService, bootstrap: SmartBackendBootstrapService);
     intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
     private handleError;
     private isSessionError;
+    private isTransportError;
     private getSessionError;
     private resolveError;
     private updateRequestHeaders;

package/lib/session/smart-session-handler.service.d.ts

@@ -17,5 +17,6 @@ export interface SessionError {
 }
 export declare enum SessionErrorBehaviour {
     REFRESH = 0,
-    RESTART = 1
+    RESTART = 1,
+    RESTART_VIEWCONTEXT = 2
 }

package/lib/session/smart-session.service.d.ts

@@ -22,10 +22,10 @@ export declare class SmartSessionService implements OnDestroy {
     isAuthenticated: boolean;
     authenticationStateChanged: Subject<boolean>;
     headerParams: Array<HeaderParam>;
-    headersUpdated: Subject<void>;
     private localStorageLocaleName;
     localeChanged: Subject<void>;
     private initializeRunning;
+    private runningRefresh?;
     sessionExpiracyChanged: Subject<void>;
     private sessionHandlerService?;
     constructor(apiService: SessionService, cookieService: SmartCookieService);
@@ -34,6 +34,19 @@ export declare class SmartSessionService implements OnDestroy {
     handleSessionError(sessionError: SessionError): Promise<void>;
     addHeaderParam(headerParam: HeaderParam): void;
     private setUpTokenForSessionService;
+    /**
+     * Hydrates the session with an externally obtained SID, bypassing
+     * `initialize()`'s backend round-trip. Used by the
+     * `SmartBackendBootstrapService.bootstrapWith()` flow when a host
+     * (e.g. native mobile shell) hands over an already-authenticated session.
+     *
+     * Persists the SID to localStorage + cookie so that a page reload can
+     * rehydrate the session through `initialize()`'s regular
+     * `tokenFromLocalStorage === tokenFromCookies` path. The optional
+     * refreshToken is persisted to enable autonomous refresh via
+     * `refreshSession()` when the SID expires.
+     */
+    setSessionToken(token: string, refreshToken?: string): void;
     setUrl(url: string): void;
     getBasePath(): string;
     setCookieName(name: string): void;
@@ -44,10 +57,12 @@ export declare class SmartSessionService implements OnDestroy {
     private startSession;
     getSession(): Promise<SessionInfoData>;
     refreshSession(): Promise<SessionInfoData>;
+    private doRefreshSession;
     private updateSessionInfo;
     private isInvalidRefreshTokenError;
     getAuthenticationProviders(): Promise<Array<AuthenticationProviderData>>;
     getIsAuthenticated(): Promise<boolean>;
+    is2FANecessary(): Promise<boolean>;
     clearAndStartNewSession(): Promise<void>;
     getLocale(): string;
     changeLocale(locale: string): Promise<void>;

package/lib/session/smart-timer/smart-session-timer.component.d.ts

@@ -1,11 +1,13 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { SmartSessionTimerService } from './smart-session-timer.service';
+import { SmartBackendBootstrapService } from '../smart-backend-bootstrap.service';
 import * as i0 from "@angular/core";
 export declare class SmartSessionTimerComponent implements OnInit, OnDestroy {
     service: SmartSessionTimerService;
+    private bootstrap;
     private _destroy$;
     timeInSeconds?: number;
-    constructor(service: SmartSessionTimerService);
+    constructor(service: SmartSessionTimerService, bootstrap: SmartBackendBootstrapService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     formatTime(seconds: number): string;

package/lib/smart-client/projects.d.ts

@@ -1,4 +1,3 @@
-export * from './smart-authentication.service';
 export * from './smart.component';
 export * from './smart-component-api-client';
 export * from './smart.service';

package/lib/smart-client/smart-component-api-client.d.ts

@@ -1,24 +1,23 @@
 import { ChangeDetectorRef, ElementRef, Injector, QueryList, Renderer2 } from '@angular/core';
 import { Subject, Subscription } from 'rxjs';
 import { SmartComponentLayoutComponent } from '../smart-component-layout/projects';
-import { SmartForm, SmartFormInvalidFields, SmartformComponent, SophisticatedValueChange } from '../smart-form/projects';
+import { SmartDiagramComponent } from '../smart-diagram/projects';
+import { SmartFilterEditorContentComponent } from '../smart-filter-editor/smart-filter-editor-content/smart-filter-editor-content.component';
+import { SmartForm, SmartFormInvalidFields, SmartformComponent, SophisticatedValueChange, ValueChangeMode } from '../smart-form/projects';
 import { GridOptions, SmartGrid, SmartGridComponent } from '../smart-grid/projects';
 import { SmartMapComponent } from '../smart-map/smart-map.component';
-import { SmarttreeGenericService } from '../smart-tree/projects';
+import { SmartTreeComponent, SmarttreeGenericService, SmarttreeService } from '../smart-tree/projects';
 import { ComponentModel, ComponentModelChange, ExecuteUiActionOptions, SmartTranslateService, SmartViewContextService, UiAction, UiActionAdditionalParams, UiActionDescriptorService, UiActionModel, UiActionRequest, UiActionService, UiActionSpecificDemandResponse, UiActionToolbarComponent, UseUiAction2 } from '../view-context/projects';
-import { SmartAuthenticationServiceInterface } from './smart-authentication.service';
-import { SmartFilterEditorContentComponent } from '../smart-filter-editor/smart-filter-editor-content/smart-filter-editor-content.component';
+import { SmartBackendBootstrapService } from '../session/smart-backend-bootstrap.service';
 export declare abstract class SmartComponentApiClient<T> implements UseUiAction2 {
     protected inject: Injector;
-    protected auth: SmartAuthenticationServiceInterface;
     protected pageName?: string | undefined;
     protected _componentName?: string | undefined;
-    protected element?: ElementRef | undefined;
+    protected element?: ElementRef<any> | undefined;
     protected renderer?: Renderer2 | undefined;
     protected _destroy$: Subject<void>;
     private detectChange;
     private _uuid?;
-    private uuidOfPageHasBeenChangedSubscription?;
     protected componentModelLoaded: boolean;
     get uuid(): string | undefined;
     set uuid(uuid: string | undefined);
@@ -32,6 +31,7 @@ export declare abstract class SmartComponentApiClient<T> implements UseUiAction2
     dataChanged: Subject<void>;
     smartGrid?: SmartGrid;
     protected viewContext: SmartViewContextService;
+    protected bootstrap: SmartBackendBootstrapService;
     protected uiActionService: UiActionService;
     protected uiActionDescriptorService: UiActionDescriptorService;
     protected translate?: SmartTranslateService;
@@ -40,46 +40,63 @@ export declare abstract class SmartComponentApiClient<T> implements UseUiAction2
     set smartTreeService(smartTreeService: SmarttreeGenericService | undefined);
     widgets: Map<string, SmartGridComponent | SmarttreeGenericService | SmartMapComponent | undefined>;
     formWidgets: Map<string, SmartformComponent | undefined>;
-    useQueryLists: boolean;
+    private _useQueryLists;
+    get useQueryLists(): boolean;
+    set useQueryLists(value: boolean);
     sendModelOnWidgetAction: boolean;
-    dataChangeKeys: string[];
-    protected dataChangeActionHandlers: Map<SmartformComponent, Subscription>;
+    inmediateDataChangeKeys: string[];
+    blurDataChangeKeys: string[];
+    protected dataChangeActionHandlers: Map<SmartformComponent, Subscription[]>;
     protected filterModelChangeSubjects: Map<string, Subject<void>>;
     protected changeDetector?: ChangeDetectorRef;
-    constructor(inject: Injector, auth: SmartAuthenticationServiceInterface, pageName?: string | undefined, _componentName?: string | undefined, element?: ElementRef | undefined, renderer?: Renderer2 | undefined);
+    constructor(inject: Injector, pageName?: string | undefined, _componentName?: string | undefined, element?: ElementRef<any> | undefined, renderer?: Renderer2 | undefined);
     _ngOnInit(): void;
     _ngOnDestroy(): void;
+    /**
+     * Called whenever this component's uuid is set to a non-null value (it may
+     * fire more than once if the uuid changes). Default: no-op.
+     * Consumers that resolved their uuid in the constructor (e.g. filter config)
+     * override this to defer that wiring until the uuid is injected — required for
+     * dynamic default components whose uuid is not known at construction. (#28870)
+     */
+    protected onUuidResolved(uuid: string): void;
     _ngAfterViewInit(): void;
-    private setupGridServices;
+    setupGridServices(grid: SmartGridComponent): void;
     private setupFilterServices;
     protected handleQueryListSimple<T>(ql: QueryList<T>, handler: () => void): void;
     protected handleQueryList<T>(ql: QueryList<T>, handler: (el: T) => void): void;
     protected abstract getSmartFormsQL(): QueryList<SmartformComponent> | undefined;
     protected abstract getSmartGridsQL(): QueryList<SmartGridComponent> | undefined;
-    protected abstract getSmartTreesQL(): QueryList<SmarttreeGenericService> | undefined;
+    protected abstract getSmartTreesQL(): QueryList<SmartTreeComponent> | undefined;
     protected abstract getSmartFilterEditorContentComponentsQL(): QueryList<SmartFilterEditorContentComponent> | undefined;
     protected abstract getSmartUiActionToolbarsQL(): QueryList<UiActionToolbarComponent> | undefined;
     protected abstract getSmartComponentLayoutsQL(): QueryList<SmartComponentLayoutComponent> | undefined;
     protected abstract getSmartMapQL(): QueryList<SmartMapComponent> | undefined;
-    protected getWidgets(): Map<string, SmartGridComponent | SmarttreeGenericService | SmartFilterEditorContentComponent | SmartMapComponent | undefined>;
+    protected abstract getSmartDiagramQL(): QueryList<SmartDiagramComponent> | undefined;
+    protected getWidgets(): Map<string, SmartGridComponent | SmarttreeService<any> | SmartFilterEditorContentComponent | SmartMapComponent | SmartDiagramComponent | undefined>;
     initComponentByModel(): void;
     protected getAllSmartFormComponents(): SmartformComponent[];
     protected getAllSmartGridComponents(): SmartGridComponent[];
     protected getAllSmartMapComponents(): Array<SmartMapComponent>;
-    protected getAllSmartTreeComponents(): SmarttreeGenericService[];
+    protected getAllSmartDiagramComponents(): Array<SmartDiagramComponent>;
+    protected getAllSmartTreeComponents(): SmarttreeService<any>[];
     protected getAllSmartFilterEditorContentComponents(): SmartFilterEditorContentComponent[];
     protected getAllSmartUiActionToolbars(): UiActionToolbarComponent[];
     protected getAllFilterUiActionToolbars(): UiActionToolbarComponent[];
     initData(): void;
     initActions(): void;
     setupAllToolbars(toolbars: UiActionToolbarComponent[], toolbarsWithoutId: UiActionToolbarComponent[], toolbarModels: Map<string, UiActionModel[]>): Promise<void>;
-    run(): void;
+    run(): Promise<void>;
     load(): Promise<void>;
     executeUiAction(uiAction: UiAction, options?: ExecuteUiActionOptions): Promise<void>;
-    addDataChangeActionHandler(key: string): void;
+    addDataChangeActionHandler(key: string, valueChangeMode: ValueChangeMode): void;
+    protected getChangeKeys(valueChangeMode: ValueChangeMode): string[];
     removeDataChangeActionHandler(key: string): void;
-    protected dataChangeActionHandler(event: SophisticatedValueChange): void;
-    protected handleDataChangeSubscriptions(): void;
+    protected dataChangeActionHandler(event: SophisticatedValueChange, valueChangeMode: ValueChangeMode): void;
+    protected handleLayoutUploadCallback(comp: SmartComponentLayoutComponent): void;
+    protected handleUploadCallback(form: SmartformComponent): void;
+    protected handleFormSubscriptions(form: SmartformComponent): void;
+    handleDataChangeSubscriptions(formComponent?: SmartformComponent): void;
     getInvalidFields(): SmartFormInvalidFields;
     protected validateForm(form: SmartformComponent | undefined, aggregatedInvalidFields: SmartFormInvalidFields): void;
     getAdditionalParams(uiAction: UiAction): UiActionAdditionalParams;
@@ -87,6 +104,9 @@ export declare abstract class SmartComponentApiClient<T> implements UseUiAction2
     submitForm(validate: boolean): void;
     performUiActionRequest(uiActionRequest: UiActionRequest, widgetId?: string, nodeId?: string): Promise<any>;
     protected addModelToWidgetAction(uiActionRequest: UiActionRequest): void;
+    addModelToWidgetParams(params: {
+        [key: string]: any;
+    }): void;
     handleSpecificDemandsAsynchronously(uiAction: UiAction, uiActionRequest: UiActionRequest): Promise<UiActionSpecificDemandResponse>;
     /**
      * Submits all the registered forms in the SmartComponent
@@ -97,6 +117,12 @@ export declare abstract class SmartComponentApiClient<T> implements UseUiAction2
     setUpDefaultTree(treeId: string): void;
     createTreeService(treeId: string): SmarttreeGenericService;
     addFileUploader(uiActionCode: string, fileFormats?: string[], maxSizeMb?: number, isMultiple?: boolean): SmartComponentFileUploader;
+    /**
+     * For dialog-hosted default components, the view uuid is passed through the
+     * dialog data (MAT_DIALOG_DATA for Material, DynamicDialogConfig.data for
+     * PrimeNG). Returns undefined for slot-hosted components (no dialog data). (#28870)
+     */
+    private readDialogDataUuid;
     private handleValueChanges;
     protected handleChanges(change: ComponentModelChange): void;
     protected handleChangeWidgets(changedWidgets: string[], skipLoad?: boolean): void;

package/lib/smart-client/smart.component.d.ts

@@ -4,30 +4,32 @@ import { SmartFilterEditorContentComponent } from '../smart-filter-editor/projec
 import { SmartformComponent } from '../smart-form/projects';
 import { SmartGridComponent } from '../smart-grid/projects';
 import { SmartMapComponent } from '../smart-map/smart-map.component';
-import { SmarttreeGenericService } from '../smart-tree/projects';
+import { SmartTreeComponent } from '../smart-tree/projects';
 import { UiActionToolbarComponent } from '../view-context/projects';
-import { SmartAuthenticationServiceInterface } from './smart-authentication.service';
 import { SmartComponentApiClient } from './smart-component-api-client';
+import { SmartDiagramComponent } from '../smart-diagram/projects';
 import * as i0 from "@angular/core";
 export declare abstract class SmartComponent<T> extends SmartComponentApiClient<T> implements OnInit, OnDestroy, AfterViewInit {
     smartFormsQL: QueryList<SmartformComponent>;
     smartGridsQL: QueryList<SmartGridComponent>;
-    smartTreesQL: QueryList<SmarttreeGenericService>;
+    smartTreesQL: QueryList<SmartTreeComponent>;
     smartComponentLayoutsQL: QueryList<SmartComponentLayoutComponent>;
     smartFilterEditorContentComponentsQL: QueryList<SmartFilterEditorContentComponent>;
     smartUiActionToolbarsQL: QueryList<UiActionToolbarComponent>;
     smartMapQL: QueryList<SmartMapComponent>;
-    constructor(inject: Injector, auth: SmartAuthenticationServiceInterface, pageName?: string, _componentName?: string, element?: ElementRef, renderer?: Renderer2);
+    smartDiagramQL: QueryList<SmartDiagramComponent>;
+    constructor(inject: Injector, pageName?: string, _componentName?: string, element?: ElementRef, renderer?: Renderer2);
     ngOnInit(): void;
     ngOnDestroy(): void;
     ngAfterViewInit(): void;
     getSmartFormsQL(): QueryList<SmartformComponent> | undefined;
     getSmartGridsQL(): QueryList<SmartGridComponent> | undefined;
-    getSmartTreesQL(): QueryList<SmarttreeGenericService> | undefined;
+    getSmartTreesQL(): QueryList<SmartTreeComponent> | undefined;
     getSmartComponentLayoutsQL(): QueryList<SmartComponentLayoutComponent> | undefined;
     getSmartFilterEditorContentComponentsQL(): QueryList<SmartFilterEditorContentComponent> | undefined;
     getSmartUiActionToolbarsQL(): QueryList<UiActionToolbarComponent> | undefined;
     getSmartMapQL(): QueryList<SmartMapComponent> | undefined;
+    getSmartDiagramQL(): QueryList<SmartDiagramComponent> | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<SmartComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SmartComponent<any>, "ng-component", never, {}, {}, never, never, false, never>;
 }

package/lib/smart-client/smart.service.d.ts

@@ -1,9 +1,8 @@
 import { AfterViewInit, Injector, OnDestroy, OnInit, QueryList } from '@angular/core';
-import { SmartAuthenticationServiceInterface } from './smart-authentication.service';
 import { SmartComponentApiClient } from './smart-component-api-client';
 import { SmartformComponent } from '../smart-form/projects';
 import { SmartGridComponent } from '../smart-grid/projects';
-import { SmarttreeGenericService } from '../smart-tree/projects';
+import { SmartTreeComponent } from '../smart-tree/projects';
 import { SmartComponentLayoutComponent } from '../smart-component-layout/projects';
 import { SmartFilterEditorContentComponent } from '../smart-filter-editor/project';
 import { UiActionToolbarComponent } from '../view-context/projects';
@@ -11,17 +10,17 @@ import * as i0 from "@angular/core";
 export declare abstract class SmartService<T> extends SmartComponentApiClient<T> implements OnInit, OnDestroy, AfterViewInit {
     smartFormsQL: QueryList<SmartformComponent>;
     smartGridsQL: QueryList<SmartGridComponent>;
-    smartTreesQL: QueryList<SmarttreeGenericService>;
+    smartTreesQL: QueryList<SmartTreeComponent>;
     smartComponentLayoutsQL: QueryList<SmartComponentLayoutComponent>;
     smartFilterEditorContentComponentsQL: QueryList<SmartFilterEditorContentComponent>;
     smartUiActionToolbarsQL: QueryList<UiActionToolbarComponent>;
-    constructor(inject: Injector, auth: SmartAuthenticationServiceInterface, pageName: string);
+    constructor(inject: Injector, pageName: string);
     ngOnInit(): void;
     ngOnDestroy(): void;
     ngAfterViewInit(): void;
     getSmartFormsQL(): QueryList<SmartformComponent> | undefined;
     getSmartGridsQL(): QueryList<SmartGridComponent> | undefined;
-    getSmartTreesQL(): QueryList<SmarttreeGenericService> | undefined;
+    getSmartTreesQL(): QueryList<SmartTreeComponent> | undefined;
     getSmartComponentLayoutsQL(): QueryList<SmartComponentLayoutComponent> | undefined;
     getSmartFilterEditorContentComponentsQL(): QueryList<SmartFilterEditorContentComponent> | undefined;
     getSmartUiActionToolbarsQL(): QueryList<UiActionToolbarComponent> | undefined;

package/lib/smart-component-layout/api/model/componentWidgetType.d.ts

@@ -14,5 +14,7 @@ export declare enum ComponentWidgetType {
     FILTER = "filter",
     TREE = "tree",
     TOOLBAR = "toolbar",
-    MAP = "map"
+    MAP = "map",
+    DIAGRAM = "diagram",
+    EMBEDDED_SLOT = "embedded_slot"
 }

package/lib/smart-component-layout/api/model/layoutDefinitionDescriptor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Form layout definition
+ * Contains form layout definition objects.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { SmartComponentLayoutDefinition } from './smartComponentLayoutDefinition';
+import { ViewConstraint } from '../../../view-context/api';
+export interface LayoutDefinitionDescriptor {
+    uri?: string;
+    name?: string;
+    layout?: SmartComponentLayoutDefinition;
+    constraint?: ViewConstraint;
+}

package/lib/smart-component-layout/api/model/models.d.ts

@@ -1,5 +1,8 @@
 export * from './componentType';
 export * from './componentWidgetType';
+export * from './layoutDefinitionDescriptor';
 export * from './layoutDirection';
 export * from './smartComponentLayoutDefinition';
 export * from './smartComponentWidgetDefinition';
+export * from './toolbarDirection';
+export * from './toolbarProperties';

package/lib/smart-component-layout/api/model/smartComponentLayoutDefinition.d.ts

@@ -22,6 +22,8 @@ export interface SmartComponentLayoutDefinition {
     type: ComponentType;
     expandable?: boolean;
     expandableSectionLabel?: string;
+    expandableSectionSubtitle?: string;
+    expandableSectionHeaderToolbarId?: string;
     direction?: LayoutDirection;
     components?: Array<SmartComponentLayoutDefinition>;
     widget?: SmartComponentWidgetDefinition;

package/lib/smart-component-layout/api/model/smartComponentWidgetDefinition.d.ts

@@ -17,4 +17,10 @@ export interface SmartComponentWidgetDefinition {
     identifier?: string;
     filterExpressionFieldList?: FilterExpressionFieldList;
     filterType?: SmartFilterType;
+    /**
+     * Additional properties the client may use to customise the appearance or behaviour of the widget.
+     */
+    properties?: {
+        [key: string]: object;
+    };
 }

package/{src/lib/smart-chart/smart-chart/api/model/chartData.d.ts → lib/smart-component-layout/api/model/toolbarDirection.d.ts}

@@ -1,6 +1,6 @@
 /**
- * Chart API
- * API for consume charts.
+ * Form layout definition
+ * Contains form layout definition objects.
  *
  * The version of the OpenAPI document: 1.0.0
  * Contact: info@it4all.hu
@@ -9,8 +9,7 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-import { ChartValue } from './chartValue';
-export interface ChartData {
-    uri?: string;
-    chartValues: Array<ChartValue>;
+export declare enum ToolbarDirection {
+    HORIZONTAL = "HORIZONTAL",
+    VERTICAL = "VERTICAL"
 }

package/lib/smart-component-layout/api/model/toolbarProperties.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Form layout definition
+ * Contains form layout definition objects.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { ToolbarDirection } from './toolbarDirection';
+export interface ToolbarProperties {
+    scrollable?: boolean;
+    direction?: ToolbarDirection;
+}