@valtimo/plugin-management 13.45.1 → 13.47.0

package/lib/components/plugin-external-permissions/plugin-external-permissions.component.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ExternalPluginGrantedEndpointEntry, ExternalPluginGrantedEventEntry, ExternalPluginEndpoint } from '@valtimo/plugin';
+import { EnrichedEndpoint } from '../../models';
+import * as i0 from "@angular/core";
+/**
+ * Lists the GZAC API endpoints, platform events, host capabilities and outbound destinations an
+ * external plugin requires. Permissions are all-or-nothing: the backend rejects a configuration
+ * unless every endpoint, `eventSubscriptions` type, capability and `permissions.egress` origin the
+ * manifest declares is granted. The admin reviews the full list and accepts all of it with a single
+ * acknowledgement before saving.
+ *
+ * The outbound-destination section has two halves, which differ in who decided them:
+ *
+ * - {@link egress} — declared in the manifest, so part of the grant the admin accepts here.
+ * - {@link derivedEgress} — origins computed from the configuration values the admin just entered in
+ *   properties marked `x-egress-target`. Not a separate grant: typing the URL *is* the grant, and it
+ *   is shown so the admin sees the complete set of destinations the plugin will be able to reach.
+ *
+ * In `readonlyMode` (editing an existing configuration) the list is informational only — the
+ * permissions were already accepted at activation — so no acknowledgement is required.
+ */
+export declare class PluginExternalPermissionsComponent implements OnChanges {
+    endpoints: Array<ExternalPluginEndpoint>;
+    eventSubscriptions: Array<string>;
+    capabilities: Array<string>;
+    /** Manifest-declared origins (`permissions.egress`), granted as a set with the rest. */
+    egress: Array<string>;
+    /** Origins derived from the admin's own `x-egress-target` configuration values. */
+    derivedEgress: Array<string>;
+    readonlyMode: boolean;
+    validEvent: EventEmitter<boolean>;
+    grantedEndpointsChange: EventEmitter<ExternalPluginGrantedEndpointEntry[]>;
+    grantedEventsChange: EventEmitter<ExternalPluginGrantedEventEntry[]>;
+    grantedCapabilitiesChange: EventEmitter<string[]>;
+    grantedEgressChange: EventEmitter<string[]>;
+    readonly $enrichedEndpoints: import("@angular/core").WritableSignal<EnrichedEndpoint[]>;
+    readonly $eventTypes: import("@angular/core").WritableSignal<string[]>;
+    readonly $capabilities: import("@angular/core").WritableSignal<string[]>;
+    readonly $egress: import("@angular/core").WritableSignal<string[]>;
+    readonly $derivedEgress: import("@angular/core").WritableSignal<string[]>;
+    readonly $accepted: import("@angular/core").WritableSignal<boolean>;
+    private readonly _externalPluginService;
+    private readonly _translateService;
+    /**
+     * True when the manifest requests nothing — no review or acknowledgement is needed then.
+     * Derived egress is deliberately not part of this: it is not a grant (the admin typing the URL
+     * is the grant), so it is only ever displayed, never accepted.
+     */
+    get isEmpty(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    onAcceptanceChange(accepted: boolean): void;
+    _httpMethodTagType(method: string): string;
+    private _endpointKey;
+    private _fetchDescriptionsAndInit;
+    private _setEnriched;
+    /**
+     * Accepting the permissions grants the full declared set — partial grants are not allowed by the
+     * backend, so the component always emits every endpoint.
+     */
+    private _emitGrantedEndpoints;
+    /**
+     * Mirror of {@link _emitGrantedEndpoints} for event subscriptions — same all-or-nothing model:
+     * the host treats the granted list as the dispatch allowlist, narrower-or-equal to the manifest's
+     * declared `eventSubscriptions`.
+     */
+    private _emitGrantedEvents;
+    private _emitGrantedCapabilities;
+    /**
+     * Only the manifest-declared origins are emitted. Derived ones are not a grant the backend accepts
+     * — it recomputes them from the configuration values on every push — so sending them would trip the
+     * exact-match check against the manifest.
+     */
+    private _emitGrantedEgress;
+    /**
+     * A `*.` entry authorises every subdomain under it, which is a materially wider grant than a fixed
+     * host — under author-controlled DNS it reopens both arbitrary-subdomain exfiltration and the DNS
+     * channel. The template renders these distinctly so the difference is visible, not buried in a list.
+     */
+    _isWildcardEgress(target: string): boolean;
+    private _emitValidity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginExternalPermissionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginExternalPermissionsComponent, "valtimo-plugin-external-permissions", never, { "endpoints": { "alias": "endpoints"; "required": false; }; "eventSubscriptions": { "alias": "eventSubscriptions"; "required": false; }; "capabilities": { "alias": "capabilities"; "required": false; }; "egress": { "alias": "egress"; "required": false; }; "derivedEgress": { "alias": "derivedEgress"; "required": false; }; "readonlyMode": { "alias": "readonlyMode"; "required": false; }; }, { "validEvent": "validEvent"; "grantedEndpointsChange": "grantedEndpointsChange"; "grantedEventsChange": "grantedEventsChange"; "grantedCapabilitiesChange": "grantedCapabilitiesChange"; "grantedEgressChange": "grantedEgressChange"; }, never, never, true, never>;
+}

package/lib/components/plugin-external-review-modal/plugin-external-review-modal.component.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ExternalPluginDefinition, ExternalPluginEndpoint, ExternalPluginService } from '@valtimo/plugin';
+import * as i0 from "@angular/core";
+/**
+ * Review-and-accept flow for a definition whose host serves different content than what was
+ * accepted (a changed plugin package, or — for URL apps without package hashing — a changed
+ * manifest). Deliberately identical to the activation flow: the full *pending* permission
+ * footprint with the standard acceptance text and all-or-nothing checkbox — no separate
+ * changed-permissions treatment. Accepting is a single call: the backend pins the reviewed
+ * content, promotes the pending manifest, and re-grants every configuration of the definition to
+ * the manifest's declared sets in one transaction.
+ */
+export declare class PluginExternalReviewModalComponent implements OnChanges {
+    private readonly _externalPluginService;
+    open: boolean;
+    definition: ExternalPluginDefinition | null;
+    closeEvent: EventEmitter<void>;
+    acceptedEvent: EventEmitter<void>;
+    readonly $loading: import("@angular/core").WritableSignal<boolean>;
+    readonly $errorMessage: import("@angular/core").WritableSignal<string>;
+    readonly $permissionsValid: import("@angular/core").WritableSignal<boolean>;
+    readonly $pendingEndpoints: import("@angular/core").WritableSignal<ExternalPluginEndpoint[]>;
+    readonly $pendingEvents: import("@angular/core").WritableSignal<string[]>;
+    readonly $pendingCapabilities: import("@angular/core").WritableSignal<string[]>;
+    readonly $pendingEgress: import("@angular/core").WritableSignal<string[]>;
+    protected readonly testIds: {
+        readonly cancelButton: "pluginExternalReviewModalCancelButton";
+        readonly acceptButton: "pluginExternalReviewModalAcceptButton";
+    };
+    constructor(_externalPluginService: ExternalPluginService);
+    ngOnChanges(changes: SimpleChanges): void;
+    onPermissionsValid(valid: boolean): void;
+    onClose(): void;
+    /**
+     * Echoes the reviewed pending hash — acceptance of a *specific* state, not of whatever the host
+     * serves by now. The backend re-grants the definition's configurations in the same act.
+     */
+    onAccept(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginExternalReviewModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginExternalReviewModalComponent, "valtimo-plugin-external-review-modal", never, { "open": { "alias": "open"; "required": false; }; "definition": { "alias": "definition"; "required": false; }; }, { "closeEvent": "closeEvent"; "acceptedEvent": "acceptedEvent"; }, never, never, true, never>;
+}

package/lib/components/plugin-host-connection-form/plugin-host-connection-form.component.d.ts

@@ -0,0 +1,85 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { FormArray, FormControl, FormGroup } from '@angular/forms';
+import { SelectItem } from '@valtimo/components';
+import { ExternalPluginEventQueueMode, ExternalPluginHost, ExternalPluginHostConnectionUpdateRequest, ExternalPluginHostCreateRequest, ExternalPluginHostKind, ExternalPluginService } from '@valtimo/plugin';
+import * as i0 from "@angular/core";
+/**
+ * The connection details form shared by host registration (plugin-host modal) and app
+ * registration (the app add stepper). Owns the form controls, the backend-provided defaults and
+ * the queue-mode/TTL validation rules; the embedding component decides when to submit and builds
+ * the create request via {@link buildRequest}.
+ */
+export declare class PluginHostConnectionFormComponent implements OnInit, OnChanges, OnDestroy {
+    private readonly _externalPluginService;
+    /** Fetches fresh defaults every time this turns true (i.e. every time the embedding modal opens). */
+    active: boolean;
+    /** Freezes the form, e.g. while connecting or after the host has been created. */
+    disabled: boolean;
+    /**
+     * Edit mode (#618): prefill from this host instead of the environment defaults, make the secret
+     * optional (blank = unchanged), and hide the event-queue and frontend-origins sections — those
+     * keep their dedicated modals. The embedder builds the update via {@link buildConnectionPatch},
+     * which sends dirty fields only, so the write-only secret and the credential-redacted broker URL
+     * never round-trip unless the admin actually retyped them.
+     */
+    editHost: ExternalPluginHost | null;
+    /** Chooses the placeholder examples: 'host' in the plugin-host modal, 'app' in the app add stepper. */
+    variant: 'host' | 'app';
+    validChange: EventEmitter<boolean>;
+    /**
+     * Matches `ExternalPluginHostService.MIN_SECRET_LENGTH` and the host's `MIN_ADMIN_TOKEN_LENGTH`.
+     * Checked here so the form names the problem instead of saving an unusable secret.
+     */
+    readonly MIN_SECRET_LENGTH = 16;
+    readonly form: FormGroup<{
+        name: FormControl<string>;
+        baseUrl: FormControl<string>;
+        secret: FormControl<string>;
+        gzacCallbackBaseUrl: FormControl<string>;
+        eventBrokerAmqpUrl: FormControl<string>;
+        eventBrokerExchange: FormControl<string>;
+        eventQueueMode: FormControl<ExternalPluginEventQueueMode>;
+        eventQueueTtlMs: FormControl<number>;
+        frontendOrigins: FormArray<FormControl<string>>;
+    }>;
+    minTtlMs: number;
+    maxTtlMs: number;
+    defaultTtlMs: number;
+    queueModeItems: SelectItem[];
+    private readonly _subscriptions;
+    /** Prefill snapshot in edit mode; [isEdited] and [buildConnectionPatch] compare against it. */
+    private _editBaseline;
+    get namePlaceholder(): string;
+    get baseUrlPlaceholder(): string;
+    get secretPlaceholder(): string;
+    get ttlHintKey(): string;
+    get frontendOriginControls(): Array<FormControl<string>>;
+    constructor(_externalPluginService: ExternalPluginService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    addFrontendOrigin(): void;
+    removeFrontendOrigin(index: number): void;
+    buildRequest(kind: ExternalPluginHostKind): ExternalPluginHostCreateRequest | null;
+    /**
+     * Whether a connection field currently differs from the value it was prefilled with. Deliberately
+     * a value comparison, not `dirty`: a field the admin edited and then reverted counts as unchanged
+     * again — the warning below it disappears and the field never travels. That also means a broker
+     * URL reverted to its redacted prefill (`amqp://***@…`) is simply not sent, instead of tripping
+     * the backend's redaction-marker guard.
+     */
+    isEdited(field: 'name' | 'baseUrl' | 'gzacCallbackBaseUrl' | 'eventBrokerAmqpUrl' | 'eventBrokerExchange'): boolean;
+    /**
+     * The connection PATCH body: fields that differ from the prefill baseline only, so an untouched
+     * secret (empty) and an untouched or reverted redacted broker URL never travel. `null` while the
+     * form is invalid; an empty object when nothing was edited — the embedder can skip the call then.
+     */
+    buildConnectionPatch(): ExternalPluginHostConnectionUpdateRequest | null;
+    reset(): void;
+    private _enterEditMode;
+    private _fetchDefaults;
+    private _setFrontendOrigins;
+    private _originControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginHostConnectionFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginHostConnectionFormComponent, "valtimo-plugin-host-connection-form", never, { "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "editHost": { "alias": "editHost"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, { "validChange": "validChange"; }, never, never, true, never>;
+}

package/lib/components/plugin-host-edit-modal/plugin-host-edit-modal.component.d.ts

@@ -0,0 +1,58 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { NotificationContent } from 'carbon-components-angular';
+import { ExternalPluginHost, ExternalPluginHostConnectionUpdateRequest } from '@valtimo/plugin';
+import { Observable } from 'rxjs';
+import { PluginHostConnectionFormComponent } from '../plugin-host-connection-form/plugin-host-connection-form.component';
+import * as i0 from "@angular/core";
+/**
+ * Edit-connection modal for a registered host or app (#618): repoint a moved host or broker, or
+ * rotate the admin secret, without recreating the row. Wraps the shared connection form in edit
+ * mode and emits the dirty-fields-only patch; the embedding page makes the call, renders its
+ * failure inline here, and handles the CSP reload when the base URL changed.
+ */
+export declare class PluginHostEditModalComponent implements OnDestroy {
+    private readonly _translateService;
+    /** Same resolve-via-setter pattern as the add modal: the body only exists while open. */
+    set connectionForm(form: PluginHostConnectionFormComponent | undefined);
+    /**
+     * A successful save closes via the parent, bypassing [onClose] — so the changed-flags are reset
+     * here too. Else the secret warning carries over to the next host opened.
+     */
+    set open(value: boolean);
+    get open(): boolean;
+    host: ExternalPluginHost | null;
+    /** Wording only: 'host' on the hosts page, 'app' on the apps page. */
+    variant: 'host' | 'app';
+    /** Disables both footer buttons and shows the inline loader while the update call is in flight. */
+    submitting: boolean;
+    /** Why the last update failed; owned by the parent, cleared here on any edit (add-modal pattern). */
+    set errorMessage(value: string | null);
+    closeEvent: EventEmitter<void>;
+    submitEvent: EventEmitter<ExternalPluginHostConnectionUpdateRequest>;
+    formValid: boolean;
+    /** Drives the rotation warning: the host must be restarted with the matching ADMIN_TOKEN. */
+    readonly $secretChanged: import("@angular/core").WritableSignal<boolean>;
+    /** Drives the consumer-reconnect note for broker edits. */
+    readonly $brokerChanged: import("@angular/core").WritableSignal<boolean>;
+    private readonly _errorMessage$;
+    private _open;
+    private _connectionForm;
+    private _formEditSubscription;
+    readonly errorNotification$: Observable<NotificationContent | null>;
+    /**
+     * Built from `stream` rather than once in the constructor: at construction time the translation
+     * file may not be loaded yet and `instant` would bake the raw keys in. Re-emits on (re)load, and
+     * stays one stable object per emission so change detection is not fed a fresh literal every pass.
+     */
+    readonly secretWarning$: Observable<NotificationContent>;
+    readonly brokerNote$: Observable<NotificationContent>;
+    constructor(_translateService: TranslateService);
+    ngOnDestroy(): void;
+    onFormValidChange(valid: boolean): void;
+    onSubmit(): void;
+    onClose(): void;
+    private _notification;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginHostEditModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginHostEditModalComponent, "valtimo-plugin-host-edit-modal", never, { "open": { "alias": "open"; "required": false; }; "host": { "alias": "host"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "submitting": { "alias": "submitting"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, { "closeEvent": "closeEvent"; "submitEvent": "submitEvent"; }, never, never, true, never>;
+}

package/lib/components/plugin-host-event-queue-modal/plugin-host-event-queue-modal.component.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { SelectItem } from '@valtimo/components';
+import { ExternalPluginEventQueueMode, ExternalPluginHost, ExternalPluginHostEventQueueUpdateRequest, ExternalPluginService } from '@valtimo/plugin';
+import * as i0 from "@angular/core";
+export declare class PluginHostEventQueueModalComponent implements OnChanges, OnInit, OnDestroy {
+    private readonly _externalPluginService;
+    open: boolean;
+    host: ExternalPluginHost | null;
+    /** Chooses the wording: 'host' on the plugin-hosts page, 'app' on the apps page. */
+    variant: 'host' | 'app';
+    closeEvent: EventEmitter<void>;
+    submitEvent: EventEmitter<ExternalPluginHostEventQueueUpdateRequest>;
+    readonly form: FormGroup<{
+        eventQueueMode: FormControl<ExternalPluginEventQueueMode>;
+        eventQueueTtlMs: FormControl<number>;
+    }>;
+    minTtlMs: number;
+    maxTtlMs: number;
+    defaultTtlMs: number;
+    queueModeItems: SelectItem[];
+    private readonly _subscriptions;
+    get ttlHintKey(): string;
+    constructor(_externalPluginService: ExternalPluginService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onSubmit(): void;
+    onClose(): void;
+    private _fetchDefaults;
+    private _loadHost;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginHostEventQueueModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginHostEventQueueModalComponent, "valtimo-plugin-host-event-queue-modal", never, { "open": { "alias": "open"; "required": false; }; "host": { "alias": "host"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, { "closeEvent": "closeEvent"; "submitEvent": "submitEvent"; }, never, never, true, never>;
+}

package/lib/components/plugin-host-frontend-origins-modal/plugin-host-frontend-origins-modal.component.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { FormArray, FormControl, FormGroup } from '@angular/forms';
+import { ExternalPluginHost } from '@valtimo/plugin';
+import * as i0 from "@angular/core";
+/**
+ * Runtime edit path for the browser origins allowed to embed a host's plugin screens — the same
+ * narrowly-scoped shape as the event-queue modal. The connection fields (base URL, secret, broker)
+ * have their own edit modal (#618).
+ *
+ * Saving an empty list is meaningful, not a mistake: it means no page may frame this host's plugins.
+ */
+export declare class PluginHostFrontendOriginsModalComponent implements OnChanges {
+    open: boolean;
+    host: ExternalPluginHost | null;
+    closeEvent: EventEmitter<void>;
+    submitEvent: EventEmitter<string[]>;
+    readonly form: FormGroup<{
+        frontendOrigins: FormArray<FormControl<string>>;
+    }>;
+    get originControls(): Array<FormControl<string>>;
+    ngOnChanges(changes: SimpleChanges): void;
+    addOrigin(): void;
+    removeOrigin(index: number): void;
+    onSubmit(): void;
+    onClose(): void;
+    private _loadHost;
+    private _originControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginHostFrontendOriginsModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginHostFrontendOriginsModalComponent, "valtimo-plugin-host-frontend-origins-modal", never, { "open": { "alias": "open"; "required": false; }; "host": { "alias": "host"; "required": false; }; }, { "closeEvent": "closeEvent"; "submitEvent": "submitEvent"; }, never, never, true, never>;
+}

package/lib/components/plugin-host-modal/plugin-host-modal.component.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { NotificationContent } from 'carbon-components-angular';
+import { ExternalPluginHostCreateRequest, ExternalPluginHostKind } from '@valtimo/plugin';
+import { Observable } from 'rxjs';
+import { PluginHostConnectionFormComponent } from '../plugin-host-connection-form/plugin-host-connection-form.component';
+import * as i0 from "@angular/core";
+export declare class PluginHostModalComponent implements OnDestroy {
+    private readonly _translateService;
+    /**
+     * The embedded connection form, resolved via a setter because the modal body only exists while
+     * the modal is open (`*ngIf`). Editing anything dismisses the previous failure: the admin is
+     * already acting on it, and a message that outlives the value it complained about is worse than
+     * none.
+     */
+    set connectionForm(form: PluginHostConnectionFormComponent | undefined);
+    open: boolean;
+    kind: ExternalPluginHostKind;
+    /** Disables both footer buttons and shows the inline loader while the create call is in flight. */
+    submitting: boolean;
+    /**
+     * Why the last create attempt failed, rendered above the fields. Owned by the parent (it is the
+     * one that makes the call) but cleared here as soon as the admin edits anything, so a stale
+     * message never sits above a form they have already corrected.
+     */
+    set errorMessage(value: string | null);
+    closeEvent: EventEmitter<void>;
+    submitEvent: EventEmitter<ExternalPluginHostCreateRequest>;
+    formValid: boolean;
+    get isApp(): boolean;
+    private readonly _errorMessage$;
+    private _connectionForm;
+    private _formEditSubscription;
+    /**
+     * The inline notification, built here rather than as a template object literal: a literal would
+     * be a new object on every change-detection pass, which keeps the notification component churning.
+     */
+    readonly errorNotification$: Observable<NotificationContent | null>;
+    constructor(_translateService: TranslateService);
+    ngOnDestroy(): void;
+    onFormValidChange(valid: boolean): void;
+    onSubmit(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginHostModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginHostModalComponent, "valtimo-plugin-host-modal", never, { "open": { "alias": "open"; "required": false; }; "kind": { "alias": "kind"; "required": false; }; "submitting": { "alias": "submitting"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, { "closeEvent": "closeEvent"; "submitEvent": "submitEvent"; }, never, never, true, never>;
+}

package/lib/components/plugin-hosts-page/plugin-hosts-page.component.d.ts

@@ -0,0 +1,84 @@
+import { OnDestroy } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { ActionItem, CarbonTag, ColumnConfig } from '@valtimo/components';
+import { ExternalPluginHost, ExternalPluginHostConnectionUpdateRequest, ExternalPluginHostCreateRequest, ExternalPluginHostEventQueueUpdateRequest, ExternalPluginHostUsage, ExternalPluginService } from '@valtimo/plugin';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { NGXLogger } from 'ngx-logger';
+import * as i0 from "@angular/core";
+export declare class PluginHostsPageComponent implements OnDestroy {
+    private readonly _logger;
+    private readonly _translateService;
+    private readonly _externalPluginService;
+    private readonly _destroy$;
+    private readonly _refreshHosts$;
+    private _hostsInitialLoad;
+    private readonly _tabVisible$;
+    readonly hostsLoading$: BehaviorSubject<boolean>;
+    readonly hostsRefreshing$: BehaviorSubject<boolean>;
+    readonly hostModalOpen$: BehaviorSubject<boolean>;
+    readonly hostSubmitting$: BehaviorSubject<boolean>;
+    readonly hostErrorMessage$: BehaviorSubject<string>;
+    readonly reloadModalOpen$: BehaviorSubject<boolean>;
+    readonly deleteHostModalOpen$: BehaviorSubject<boolean>;
+    hostToDelete: ExternalPluginHost | null;
+    readonly editConnectionModalOpen$: BehaviorSubject<boolean>;
+    readonly hostToEditConnection$: BehaviorSubject<ExternalPluginHost>;
+    readonly editConnectionSubmitting$: BehaviorSubject<boolean>;
+    readonly editConnectionErrorMessage$: BehaviorSubject<string>;
+    readonly eventQueueModalOpen$: BehaviorSubject<boolean>;
+    readonly hostToEditEventQueue$: BehaviorSubject<ExternalPluginHost>;
+    readonly frontendOriginsModalOpen$: BehaviorSubject<boolean>;
+    readonly hostToEditFrontendOrigins$: BehaviorSubject<ExternalPluginHost>;
+    readonly usageModalOpen$: BehaviorSubject<boolean>;
+    readonly usageModalUsages$: BehaviorSubject<ExternalPluginHostUsage[]>;
+    usageModalEntityName: string | null;
+    usageModalTitleKey: string;
+    usageModalDescriptionKey: string;
+    readonly hostFields: ColumnConfig[];
+    readonly hostActionItems: ActionItem[];
+    readonly hosts$: Observable<Array<ExternalPluginHost & {
+        statusTag: CarbonTag;
+        lastHealthCheckFormatted: string;
+    }>>;
+    constructor(_logger: NGXLogger, _translateService: TranslateService, _externalPluginService: ExternalPluginService);
+    ngOnDestroy(): void;
+    openHostModal(): void;
+    closeHostModal(): void;
+    /**
+     * Keeps the modal open and populated when registration fails, showing the reason inline. The
+     * backend answers a fixable mistake with a 400 carrying `detail`; the service marks that status
+     * `InterceptorSkip`, so this is the only place the admin ever sees it.
+     */
+    submitHost(request: ExternalPluginHostCreateRequest): void;
+    editHostFrontendOrigins(host: ExternalPluginHost): void;
+    closeFrontendOriginsModal(): void;
+    submitFrontendOriginsUpdate(origins: Array<string>): void;
+    /**
+     * The most specific message the response carries. `detail` is what the backend's validation
+     * mapper fills with the operator-facing reason; `message`/`title` cover the other problem shapes;
+     * the translated fallback covers a response with none of them (a gateway error, say).
+     */
+    private _extractHostError;
+    deleteHost(host: ExternalPluginHost): void;
+    confirmDeleteHost(): void;
+    cancelDeleteHost(): void;
+    editHostConnection(host: ExternalPluginHost): void;
+    closeEditConnectionModal(): void;
+    /**
+     * Applies the dirty-fields-only connection patch (#618). A changed base URL also changes the
+     * origin the frontend CSP must allow, and that CSP is fixed at bootstrap — so a repoint gets the
+     * same reload-required modal as registering a new host.
+     */
+    submitConnectionUpdate(patch: ExternalPluginHostConnectionUpdateRequest): void;
+    editHostEventQueue(host: ExternalPluginHost): void;
+    closeEventQueueModal(): void;
+    submitEventQueueUpdate(request: ExternalPluginHostEventQueueUpdateRequest): void;
+    closeUsageModal(): void;
+    confirmReload(): void;
+    cancelReload(): void;
+    private _showHostInUseModal;
+    private _getStatusTag;
+    private _formatLastHealthCheck;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginHostsPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginHostsPageComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/lib/components/plugin-log-modal/plugin-log-modal.component.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter, OnChanges, SimpleChanges, TemplateRef } from '@angular/core';
+import { CarbonPaginatorConfig, ColumnConfig, Pagination } from '@valtimo/components';
+import { PluginLogEntry } from '@valtimo/plugin';
+import { ListItem } from 'carbon-components-angular';
+import * as i0 from "@angular/core";
+export declare class PluginLogModalComponent implements OnChanges {
+    open: boolean;
+    configurationId: string | null;
+    configurationTitle: string;
+    closeModal: EventEmitter<void>;
+    timestampTpl: TemplateRef<any>;
+    levelTpl: TemplateRef<any>;
+    sourceTpl: TemplateRef<any>;
+    readonly $loading: import("@angular/core").WritableSignal<boolean>;
+    readonly $rows: import("@angular/core").WritableSignal<PluginLogEntry[]>;
+    readonly $selectedRow: import("@angular/core").WritableSignal<PluginLogEntry>;
+    private readonly _$totalElements;
+    fields: ColumnConfig[];
+    page: number;
+    pageSize: number;
+    readonly paginatorConfig: CarbonPaginatorConfig;
+    levelItems: Partial<ListItem>[];
+    sourceItems: Partial<ListItem>[];
+    private _levelFilter;
+    private _sourceFilter;
+    private readonly _externalPluginService;
+    private readonly _iconService;
+    private readonly _cdr;
+    private readonly _translateService;
+    constructor();
+    get pagination(): Pagination;
+    ngOnChanges(changes: SimpleChanges): void;
+    onClose(): void;
+    onPaginationClicked(page: number): void;
+    onRowClicked(row: PluginLogEntry): void;
+    onLevelSelected(event: {
+        item: {
+            value: string;
+        };
+    }): void;
+    onSourceSelected(event: {
+        item: {
+            value: string;
+        };
+    }): void;
+    closeDetail(): void;
+    levelTagType(level: string): string;
+    sourceTagType(source: string): string;
+    formatData(data: unknown): string;
+    private _resetFilters;
+    private _initFields;
+    private _loadLogs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginLogModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginLogModalComponent, "valtimo-plugin-log-modal", never, { "open": { "alias": "open"; "required": false; }; "configurationId": { "alias": "configurationId"; "required": false; }; "configurationTitle": { "alias": "configurationTitle"; "required": false; }; }, { "closeModal": "closeModal"; }, never, never, true, never>;
+}