@valtimo/plugin-management 13.46.0 → 13.47.0

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

@@ -1,25 +1,101 @@
-import { EventEmitter } from '@angular/core';
+import { EventEmitter, OnDestroy } from '@angular/core';
 import { PluginManagementStateService } from '../../services';
-import { BehaviorSubject, Subject } from 'rxjs';
-import { PluginConfigurationData, PluginManagementService } from '@valtimo/plugin';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ExternalPluginDefinition, ExternalPluginGrantedEndpointEntry, ExternalPluginGrantedEventEntry, ExternalPluginEndpoint, ExternalPluginService, PluginConfigurationData, PluginManagementService } from '@valtimo/plugin';
 import { NGXLogger } from 'ngx-logger';
+import { TranslateService } from '@ngx-translate/core';
 import * as i0 from "@angular/core";
-export declare class PluginAddModalComponent {
-    private readonly stateService;
-    private readonly pluginManagementService;
-    private readonly logger;
-    open: boolean;
+export declare class PluginAddModalComponent implements OnDestroy {
+    private readonly _stateService;
+    private readonly _pluginManagementService;
+    private readonly _externalPluginService;
+    private readonly _logger;
+    private readonly _translateService;
+    /**
+     * Opening with a plugin already selected — the "Configure plugin" action on the upload
+     * notification does exactly that — skips the choose-a-plugin step and lands on the configuration
+     * form, which is the whole point of that shortcut.
+     */
+    set open(value: boolean);
+    get open(): boolean;
+    set externalDefinitions(value: ExternalPluginDefinition[] | null);
+    get externalDefinitions(): ExternalPluginDefinition[] | null;
     closeModal: EventEmitter<boolean>;
-    readonly inputDisabled$: import("rxjs").Observable<boolean>;
-    readonly selectedPluginDefinition$: import("rxjs").Observable<import("@valtimo/plugin").PluginDefinition>;
+    readonly inputDisabled$: Observable<boolean>;
+    readonly selectedPluginDefinition$: Observable<import("@valtimo/plugin").PluginDefinition>;
     readonly configurationValid$: BehaviorSubject<boolean>;
-    readonly returnToFirstStepSubject$: Subject<boolean>;
-    constructor(stateService: PluginManagementStateService, pluginManagementService: PluginManagementService, logger: NGXLogger);
+    private _open;
+    private _externalDefinitions;
+    private readonly _externalDefinitions$;
+    readonly isExternalPlugin$: Observable<boolean>;
+    /**
+     * The localized compatibility warning to show on the configure step, or null when the selected
+     * plugin is embedded, compatible, or not yet chosen. Recomputed on language change so the message
+     * stays localized.
+     */
+    readonly incompatibleWarning$: Observable<string | null>;
+    readonly endpoints$: BehaviorSubject<ExternalPluginEndpoint[]>;
+    readonly eventSubscriptions$: BehaviorSubject<string[]>;
+    readonly capabilities$: BehaviorSubject<string[]>;
+    readonly egress$: BehaviorSubject<string[]>;
+    readonly derivedEgress$: BehaviorSubject<string[]>;
+    readonly permissionsValid$: BehaviorSubject<boolean>;
+    currentStepIndex: number;
+    isExternal: boolean;
+    progressSteps: Array<{
+        label: string;
+        complete: boolean;
+    }>;
+    private _externalConfigureComponent;
+    private readonly _subscriptions;
+    constructor(_stateService: PluginManagementStateService, _pluginManagementService: PluginManagementService, _externalPluginService: ExternalPluginService, _logger: NGXLogger, _translateService: TranslateService);
+    ngOnDestroy(): void;
+    /**
+     * Lands on the configuration step when the modal is opened while a plugin is already selected.
+     * The step count itself is already right by now: `isExternal` is kept in sync from the
+     * constructor's `isExternalPlugin$` subscription, which fires synchronously off the selection.
+     */
+    private _skipSelectStepWhenPreselected;
+    goToNextStep(): void;
     complete(): void;
     hide(): void;
     onValid(valid: boolean): void;
     onConfiguration(configuration: PluginConfigurationData): void;
-    private returnToFirstStep;
+    onEndpointsResolved(endpoints: Array<ExternalPluginEndpoint>): void;
+    onEventSubscriptionsResolved(eventTypes: Array<string>): void;
+    onPermissionsValid(valid: boolean): void;
+    onGrantedEndpointsChange(endpoints: Array<ExternalPluginGrantedEndpointEntry>): void;
+    onGrantedEventsChange(events: Array<ExternalPluginGrantedEventEntry>): void;
+    onCapabilitiesResolved(caps: Array<string>): void;
+    onGrantedCapabilitiesChange(caps: Array<string>): void;
+    onEgressResolved(targets: Array<string>): void;
+    /**
+     * Derived destinations don't gate the step — the admin already supplied them by typing the value —
+     * so this only refreshes the display.
+     */
+    onDerivedEgressResolved(targets: Array<string>): void;
+    onGrantedEgressChange(targets: Array<string>): void;
+    onExternalSave(event: {
+        definitionId: string;
+        title: string;
+        properties: Record<string, unknown>;
+        grantedEndpoints: Array<ExternalPluginGrantedEndpointEntry>;
+        grantedEvents: Array<ExternalPluginGrantedEventEntry>;
+        grantedCapabilities: Array<string>;
+        grantedEgress: Array<string>;
+    }): void;
+    /**
+     * Permissions step starts valid (no acknowledgement required) only when the plugin declared nothing
+     * to acknowledge — no endpoints, events, capabilities or manifest egress targets. The
+     * acknowledgement otherwise gates the step.
+     */
+    private _recomputePermissionsValid;
+    /**
+     * Carbon's progress indicator recomputes step completion only inside its `current` setter, so a
+     * rebuilt steps array (language change, plugin-kind change) must carry the `complete` flags
+     * itself — with an unchanged current step the rebuild would otherwise wipe the checkmarks.
+     */
+    private _buildProgressSteps;
     static ɵfac: i0.ɵɵFactoryDeclaration<PluginAddModalComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PluginAddModalComponent, "valtimo-plugin-add-modal", never, { "open": { "alias": "open"; "required": false; }; }, { "closeModal": "closeModal"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginAddModalComponent, "valtimo-plugin-add-modal", never, { "open": { "alias": "open"; "required": false; }; "externalDefinitions": { "alias": "externalDefinitions"; "required": false; }; }, { "closeModal": "closeModal"; }, never, never, false, never>;
 }

package/lib/components/plugin-add-select/plugin-add-select.component.d.ts

@@ -1,29 +1,35 @@
 import { OnDestroy, OnInit } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
 import { PluginManagementStateService } from '../../services';
-import { PluginDefinition, PluginManagementService } from '@valtimo/plugin';
+import { UnifiedPluginDefinition } from '../../models';
+import { ExternalPluginDefinition, PluginDefinition, PluginManagementService } from '@valtimo/plugin';
 import * as i0 from "@angular/core";
 export declare class PluginAddSelectComponent implements OnInit, OnDestroy {
-    private readonly pluginManagementService;
-    private readonly stateService;
-    readonly selectedPluginDefinition$: import("rxjs").Observable<PluginDefinition>;
-    readonly disabled$: import("rxjs").Observable<boolean>;
-    readonly pluginDefinitionsWithLogos$: import("rxjs").Observable<import("@valtimo/plugin").PluginDefinitionWithLogo[]>;
+    private readonly _pluginManagementService;
+    private readonly _stateService;
+    private readonly _translateService;
+    set externalDefinitions(value: ExternalPluginDefinition[] | null);
+    readonly selectedPluginDefinition$: Observable<PluginDefinition>;
+    readonly disabled$: Observable<boolean>;
     readonly testIds: {
         readonly tileGrid: "pluginCatalogTileGrid";
         readonly tileLogo: "pluginCatalogTileLogo";
         readonly tileTitle: "pluginCatalogTileTitle";
         readonly tileDescription: "pluginCatalogTileDescription";
     };
-    private refreshSubscription;
-    constructor(pluginManagementService: PluginManagementService, stateService: PluginManagementStateService);
+    private readonly _externalDefs$;
+    readonly allDefinitions$: Observable<UnifiedPluginDefinition[] | undefined>;
+    private readonly _subscriptions;
+    constructor(_pluginManagementService: PluginManagementService, _stateService: PluginManagementStateService, _translateService: TranslateService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     selectPluginDefinition(event: {
         value: PluginDefinition;
     }): void;
     deselectPluginDefinition(): void;
-    private getPluginDefinitions;
-    private openRefreshSubscription;
+    private _getPluginDefinitions;
+    private _openRefreshSubscription;
     static ɵfac: i0.ɵɵFactoryDeclaration<PluginAddSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PluginAddSelectComponent, "valtimo-plugin-add-select", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginAddSelectComponent, "valtimo-plugin-add-select", never, { "externalDefinitions": { "alias": "externalDefinitions"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/components/plugin-app-add-modal/plugin-app-add-modal.component.d.ts

@@ -0,0 +1,127 @@
+import { EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { ExternalPluginDefinition, ExternalPluginGrantedEndpointEntry, ExternalPluginGrantedEventEntry, ExternalPluginEndpoint, ExternalPluginService } from '@valtimo/plugin';
+import { NGXLogger } from 'ngx-logger';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+type ConnectState = 'idle' | 'connecting' | 'connected' | 'failed' | 'conflict' | 'timeout';
+/**
+ * Connects an app and configures it in a single stepper: Connect → Enter data → Permissions.
+ *
+ * Connecting registers the app as an external plugin host (kind APP) and waits for the app's
+ * plugin definition to be discovered. Because the CSP meta tag is fixed at bootstrap, an app that
+ * ships its own config bundle cannot be framed until the page is reloaded — in that case a
+ * confirmation dialog announces the refresh and the flow resumes at the configuration step via
+ * the `configureApp` query parameter on the apps page (see {@link PluginAppsPageComponent}).
+ * When the current CSP already allows the app's origin (or no CSP is configured), the stepper
+ * continues without a refresh.
+ */
+export declare class PluginAppAddModalComponent implements OnChanges, OnDestroy {
+    private readonly _externalPluginService;
+    private readonly _translateService;
+    private readonly _logger;
+    private _connectionForm;
+    private _configureComponent;
+    open: boolean;
+    /** When set, the stepper opens at the configuration step for this already-connected app. */
+    resumeHostId: string | null;
+    closeEvent: EventEmitter<void>;
+    completedEvent: EventEmitter<void>;
+    readonly $currentStep: import("@angular/core").WritableSignal<number>;
+    readonly $connectState: import("@angular/core").WritableSignal<ConnectState>;
+    readonly $connectionFormValid: import("@angular/core").WritableSignal<boolean>;
+    readonly $definition: import("@angular/core").WritableSignal<ExternalPluginDefinition>;
+    readonly $resolvingDefinition: import("@angular/core").WritableSignal<boolean>;
+    readonly $resumeLoadFailed: import("@angular/core").WritableSignal<boolean>;
+    readonly $configValid: import("@angular/core").WritableSignal<boolean>;
+    readonly $permissionsValid: import("@angular/core").WritableSignal<boolean>;
+    readonly $saving: import("@angular/core").WritableSignal<boolean>;
+    readonly $endpoints: import("@angular/core").WritableSignal<ExternalPluginEndpoint[]>;
+    readonly $eventSubscriptions: 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[]>;
+    /** Details of the conflicting registration, shown when connecting is rejected with a 409. */
+    readonly $conflict: import("@angular/core").WritableSignal<{
+        pluginId: string;
+        hostName: string;
+    }>;
+    /**
+     * Why connecting failed, rendered in the failed notification. The backend answers a fixable
+     * mistake (a bind address as base URL, a broker over plaintext HTTP) with a 400 whose `detail`
+     * explains it — `createHost` keeps that off the global error toast so it can be shown here.
+     */
+    readonly $connectError: import("@angular/core").WritableSignal<string>;
+    readonly refreshModalOpen$: BehaviorSubject<boolean>;
+    progressSteps: Array<{
+        label: string;
+        complete: boolean;
+    }>;
+    protected readonly testIds: {
+        readonly cancelButton: "pluginAppAddModalCancelButton";
+        readonly connectButton: "pluginAppAddModalConnectButton";
+        readonly continueButton: "pluginAppAddModalContinueButton";
+        readonly retryButton: "pluginAppAddModalRetryButton";
+        readonly nextButton: "pluginAppAddModalNextButton";
+        readonly completeButton: "pluginAppAddModalCompleteButton";
+    };
+    private _host;
+    private _definitionPollSubscription;
+    private readonly _subscriptions;
+    /** The connection form stays locked from the moment the host is created. */
+    get connectionLocked(): boolean;
+    constructor(_externalPluginService: ExternalPluginService, _translateService: TranslateService, _logger: NGXLogger);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onConnectionFormValidChange(valid: boolean): void;
+    onConnect(): void;
+    onRetryDiscovery(): void;
+    onContinue(): void;
+    onRefreshConfirm(): void;
+    onRefreshCancel(): void;
+    onConfigValid(valid: boolean): void;
+    onEndpointsResolved(endpoints: Array<ExternalPluginEndpoint>): void;
+    onEventSubscriptionsResolved(eventTypes: Array<string>): void;
+    onCapabilitiesResolved(capabilities: Array<string>): void;
+    onEgressResolved(targets: Array<string>): void;
+    onDerivedEgressResolved(targets: Array<string>): void;
+    onPermissionsValid(valid: boolean): void;
+    onGrantedEndpointsChange(endpoints: Array<ExternalPluginGrantedEndpointEntry>): void;
+    onGrantedEventsChange(events: Array<ExternalPluginGrantedEventEntry>): void;
+    onGrantedCapabilitiesChange(capabilities: Array<string>): void;
+    onGrantedEgressChange(targets: Array<string>): void;
+    goToPermissionsStep(): void;
+    onComplete(): void;
+    onExternalSave(event: {
+        definitionId: string;
+        title: string;
+        properties: Record<string, unknown>;
+        grantedEndpoints: Array<ExternalPluginGrantedEndpointEntry>;
+        grantedEvents: Array<ExternalPluginGrantedEventEntry>;
+        grantedCapabilities: Array<string>;
+        grantedEgress: Array<string>;
+    }): void;
+    onClose(): void;
+    private _startResume;
+    /**
+     * Discovery runs synchronously (best-effort) when the host is created, so the definition is
+     * usually there on the first try; the poll covers an app that is slow to come up, bounded to
+     * roughly the backend's own periodic discovery interval.
+     */
+    private _pollForDefinition;
+    private _stopDefinitionPoll;
+    private _buildResumeUrl;
+    /** See `PluginHostsPageComponent._extractHostError` — the message precedence is identical. */
+    private _extractConnectError;
+    private _resetAfterClose;
+    /**
+     * Carbon's progress indicator recomputes step completion only inside its `current` setter, so a
+     * rebuilt steps array must carry the `complete` flags itself: a rebuild with an unchanged current
+     * step — the translation file finishing to load after the modal already resumed at the
+     * configuration step — would otherwise wipe the checkmarks of the completed steps.
+     */
+    private _buildProgressSteps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginAppAddModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginAppAddModalComponent, "valtimo-plugin-app-add-modal", never, { "open": { "alias": "open"; "required": false; }; "resumeHostId": { "alias": "resumeHostId"; "required": false; }; }, { "closeEvent": "closeEvent"; "completedEvent": "completedEvent"; }, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,120 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { ActionItem, CarbonTag, ColumnConfig } from '@valtimo/components';
+import { ExternalPluginConfiguration, ExternalPluginDefinition, ExternalPluginHost, ExternalPluginHostConnectionUpdateRequest, ExternalPluginHostEventQueueUpdateRequest, ExternalPluginHostUsage, ExternalPluginService } from '@valtimo/plugin';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { NGXLogger } from 'ngx-logger';
+import { UnifiedPluginConfigurationRow } from '../../models';
+import * as i0 from "@angular/core";
+/** One row on the apps page: the APP-kind host enriched with its discovered plugin and configuration. */
+interface PluginAppRow extends ExternalPluginHost {
+    statusTags: CarbonTag[];
+    lastHealthCheckFormatted: string;
+    configurationTitle: string;
+    definition: ExternalPluginDefinition | null;
+    configuration: ExternalPluginConfiguration | null;
+    /** Whether the app's plugin declares the `log` capability — apps without it serve no logs endpoint. */
+    supportsLogs: boolean;
+    /** The app changed its manifest/version after acceptance; an admin must review before it runs again. */
+    reviewRequired: boolean;
+}
+export declare class PluginAppsPageComponent implements OnInit, OnDestroy {
+    private readonly _logger;
+    private readonly _route;
+    private readonly _router;
+    private readonly _translateService;
+    private readonly _externalPluginService;
+    private readonly _destroy$;
+    private readonly _refreshApps$;
+    private _appsInitialLoad;
+    private readonly _tabVisible$;
+    readonly appsLoading$: BehaviorSubject<boolean>;
+    readonly appsRefreshing$: BehaviorSubject<boolean>;
+    readonly $addModalOpen: import("@angular/core").WritableSignal<boolean>;
+    readonly $resumeHostId: import("@angular/core").WritableSignal<string>;
+    readonly refreshModalOpen$: BehaviorSubject<boolean>;
+    private _pendingRefreshHostId;
+    readonly $editModalOpen: import("@angular/core").WritableSignal<boolean>;
+    readonly $selectedConfiguration: import("@angular/core").WritableSignal<UnifiedPluginConfigurationRow>;
+    readonly $reviewModalOpen: import("@angular/core").WritableSignal<boolean>;
+    readonly $reviewDefinition: import("@angular/core").WritableSignal<ExternalPluginDefinition>;
+    readonly deleteConfigurationModalOpen$: BehaviorSubject<boolean>;
+    configurationToDelete: {
+        id: string;
+        title: string;
+    } | null;
+    readonly $logModalOpen: import("@angular/core").WritableSignal<boolean>;
+    readonly $logConfigurationId: import("@angular/core").WritableSignal<string>;
+    readonly $logConfigurationTitle: import("@angular/core").WritableSignal<string>;
+    readonly deleteHostModalOpen$: BehaviorSubject<boolean>;
+    hostToDelete: ExternalPluginHost | null;
+    readonly eventQueueModalOpen$: BehaviorSubject<boolean>;
+    readonly hostToEditEventQueue$: BehaviorSubject<ExternalPluginHost>;
+    readonly editConnectionModalOpen$: BehaviorSubject<boolean>;
+    readonly hostToEditConnection$: BehaviorSubject<ExternalPluginHost>;
+    readonly editConnectionSubmitting$: BehaviorSubject<boolean>;
+    readonly editConnectionErrorMessage$: BehaviorSubject<string>;
+    readonly reloadModalOpen$: BehaviorSubject<boolean>;
+    readonly frontendOriginsModalOpen$: BehaviorSubject<boolean>;
+    readonly hostToEditFrontendOrigins$: BehaviorSubject<ExternalPluginHost>;
+    readonly usageModalOpen$: BehaviorSubject<boolean>;
+    readonly usageModalUsages$: BehaviorSubject<ExternalPluginHostUsage[]>;
+    usageModalEntityName: string | null;
+    usageModalTitleKey: string;
+    usageModalDescriptionKey: string;
+    readonly appFields: ColumnConfig[];
+    readonly appActionItems: ActionItem[];
+    readonly apps$: Observable<Array<PluginAppRow>>;
+    constructor(_logger: NGXLogger, _route: ActivatedRoute, _router: Router, _translateService: TranslateService, _externalPluginService: ExternalPluginService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    openAddModal(): void;
+    onAddModalClose(): void;
+    onAddModalCompleted(): void;
+    onRowClicked(row: PluginAppRow): void;
+    reviewChanges(row: PluginAppRow): void;
+    closeReviewModal(): void;
+    onReviewAccepted(): void;
+    configureApp(row: PluginAppRow): void;
+    onRefreshConfirm(): void;
+    onRefreshCancel(): void;
+    private _openResume;
+    private _closeAddModal;
+    /** Keeps the resume parameter in the URL while configuring, so a manual reload restores the step. */
+    private _setConfigureAppQueryParam;
+    editConfiguration(row: PluginAppRow): void;
+    closeEditModal(): void;
+    onConfigurationSaved(): void;
+    onConfigurationDeleteRequested(configurationId: string): void;
+    confirmDeleteConfiguration(): void;
+    cancelDeleteConfiguration(): void;
+    viewLogs(row: PluginAppRow): void;
+    closeLogModal(): void;
+    deleteHost(host: ExternalPluginHost): void;
+    confirmDeleteHost(): void;
+    cancelDeleteHost(): void;
+    editHostEventQueue(host: ExternalPluginHost): void;
+    closeEventQueueModal(): void;
+    submitEventQueueUpdate(request: ExternalPluginHostEventQueueUpdateRequest): void;
+    editHostConnection(host: ExternalPluginHost): void;
+    closeEditConnectionModal(): void;
+    /** Same reload rule as the hosts page: a new base URL means a new CSP frame origin. */
+    submitConnectionUpdate(patch: ExternalPluginHostConnectionUpdateRequest): void;
+    confirmReload(): void;
+    cancelReload(): void;
+    editHostFrontendOrigins(host: ExternalPluginHost): void;
+    closeFrontendOriginsModal(): void;
+    submitFrontendOriginsUpdate(origins: Array<string>): void;
+    /** Mirrors the hosts page: `detail` is the operator-facing reason the validation mapper fills. */
+    private _extractHostError;
+    closeUsageModal(): void;
+    private _toAppRow;
+    private _showHostInUseModal;
+    private _showConfigurationInUseModal;
+    private _getStatusTag;
+    private _formatLastHealthCheck;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginAppsPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginAppsPageComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+export {};

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

@@ -11,6 +11,10 @@ export declare class PluginEditModalComponent {
     readonly open = false;
     readonly saveNewConfiguration = false;
     closeModal: EventEmitter<boolean>;
+    deleteEvent: EventEmitter<{
+        configurationId: string;
+        configurationTitle: string;
+    }>;
     readonly inputDisabled$: Observable<boolean>;
     readonly selectedPluginConfiguration$: Observable<PluginConfiguration>;
     readonly configurationValid$: BehaviorSubject<boolean>;
@@ -20,11 +24,16 @@ export declare class PluginEditModalComponent {
     };
     constructor(stateService: PluginManagementStateService, pluginManagementService: PluginManagementService, logger: NGXLogger);
     save(): void;
+    /**
+     * Bubble the delete request up to the parent so the shared usage pre-check +
+     * destructive-confirmation flow runs in one place (mirrors how the external edit modal works).
+     * The parent closes this modal as part of that flow.
+     */
     delete(): void;
     hide(): void;
     onPluginValid(valid: boolean): void;
     onPluginConfiguration(configuration: PluginConfigurationData): void;
     private saveNewPluginConfiguration;
     static ɵfac: i0.ɵɵFactoryDeclaration<PluginEditModalComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PluginEditModalComponent, "valtimo-plugin-edit-modal", never, { "open": { "alias": "open"; "required": false; }; "saveNewConfiguration": { "alias": "saveNewConfiguration"; "required": false; }; }, { "closeModal": "closeModal"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginEditModalComponent, "valtimo-plugin-edit-modal", never, { "open": { "alias": "open"; "required": false; }; "saveNewConfiguration": { "alias": "saveNewConfiguration"; "required": false; }; }, { "closeModal": "closeModal"; "deleteEvent": "deleteEvent"; }, never, never, false, never>;
 }

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

@@ -0,0 +1,78 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { ExternalPluginGrantedEndpointEntry, ExternalPluginGrantedEventEntry, ExternalPluginEndpoint, ExternalPluginService } from '@valtimo/plugin';
+import { PluginManagementStateService } from '../../services';
+import * as i0 from "@angular/core";
+interface ExternalPluginSaveEvent {
+    definitionId: string;
+    title: string;
+    properties: Record<string, unknown>;
+    grantedEndpoints: Array<ExternalPluginGrantedEndpointEntry>;
+    grantedEvents: Array<ExternalPluginGrantedEventEntry>;
+    grantedCapabilities: Array<string>;
+    grantedEgress: Array<string>;
+}
+/**
+ * The "enter data" step for an external plugin configuration: the plugin's own config bundle in an
+ * iframe when it ships one, a title + JSON properties fallback otherwise.
+ *
+ * Works in two modes:
+ * - Bound to {@link PluginManagementStateService} (the plugins page add modal): the definition
+ *   follows the selected plugin and saving is triggered through the state service's `save$`.
+ * - Standalone via the `definitionId` input (the app add stepper): the definition is loaded
+ *   directly and saving is triggered imperatively through {@link triggerSave}.
+ */
+export declare class PluginExternalConfigureComponent implements OnInit, OnDestroy {
+    private readonly _stateService;
+    private readonly _externalPluginService;
+    /** When set, configures this definition directly instead of the state service's selection. */
+    definitionId: string | null;
+    validEvent: EventEmitter<boolean>;
+    saveEvent: EventEmitter<ExternalPluginSaveEvent>;
+    endpointsResolved: EventEmitter<ExternalPluginEndpoint[]>;
+    eventSubscriptionsResolved: EventEmitter<string[]>;
+    capabilitiesResolved: EventEmitter<string[]>;
+    egressResolved: EventEmitter<string[]>;
+    /**
+     * The origins GZAC will derive from the configuration values entered on this step, recomputed as
+     * they change. Not a grant — the admin supplying the URL is the grant — but the permissions step
+     * shows them so the full destination set is visible before activation.
+     */
+    derivedEgressResolved: EventEmitter<string[]>;
+    readonly $configBundleUrl: import("@angular/core").WritableSignal<string>;
+    readonly $loading: import("@angular/core").WritableSignal<boolean>;
+    readonly _form: FormGroup<{
+        title: FormControl<string>;
+        properties: FormControl<string>;
+    }>;
+    private _definitionId;
+    private _iframeConfigTitle;
+    private _iframeConfigData;
+    private _grantedEndpoints;
+    private _grantedEvents;
+    private _grantedCapabilities;
+    private _grantedEgress;
+    private _configurationSchema;
+    private readonly _subscriptions;
+    constructor(_stateService: PluginManagementStateService, _externalPluginService: ExternalPluginService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Imperative save trigger for the `definitionId` mode (mirrors the state service's `save$`). */
+    triggerSave(): void;
+    onIframeConfigurationChanged(event: {
+        valid: boolean;
+        title: string;
+        data: Record<string, unknown>;
+    }): void;
+    setGrantedEndpoints(endpoints: Array<ExternalPluginGrantedEndpointEntry>): void;
+    setGrantedEvents(events: Array<ExternalPluginGrantedEventEntry>): void;
+    setGrantedCapabilities(caps: Array<string>): void;
+    setGrantedEgress(targets: Array<string>): void;
+    private _applyDefinition;
+    private _emitDerivedEgress;
+    private _validateForm;
+    private _onSaveTriggered;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginExternalConfigureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginExternalConfigureComponent, "valtimo-plugin-external-configure", never, { "definitionId": { "alias": "definitionId"; "required": false; }; }, { "validEvent": "validEvent"; "saveEvent": "saveEvent"; "endpointsResolved": "endpointsResolved"; "eventSubscriptionsResolved": "eventSubscriptionsResolved"; "capabilitiesResolved": "capabilitiesResolved"; "egressResolved": "egressResolved"; "derivedEgressResolved": "derivedEgressResolved"; }, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,79 @@
+import { EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { ExternalPluginEndpoint, ExternalPluginService } from '@valtimo/plugin';
+import { UnifiedPluginConfigurationRow } from '../../models';
+import * as i0 from "@angular/core";
+export declare class PluginExternalEditModalComponent implements OnChanges, OnDestroy {
+    private readonly _externalPluginService;
+    private readonly _translateService;
+    open: boolean;
+    configuration: UnifiedPluginConfigurationRow | null;
+    closeEvent: EventEmitter<void>;
+    savedEvent: EventEmitter<void>;
+    deleteEvent: EventEmitter<string>;
+    readonly _form: FormGroup<{
+        title: FormControl<string>;
+        properties: FormControl<string>;
+    }>;
+    readonly $loading: import("@angular/core").WritableSignal<boolean>;
+    readonly $propertiesInvalid: import("@angular/core").WritableSignal<boolean>;
+    readonly $configBundleUrl: import("@angular/core").WritableSignal<string>;
+    readonly $prefillConfiguration: import("@angular/core").WritableSignal<{
+        title: string;
+        configuration: Record<string, unknown>;
+    }>;
+    readonly $endpoints: import("@angular/core").WritableSignal<ExternalPluginEndpoint[]>;
+    readonly $eventSubscriptions: import("@angular/core").WritableSignal<string[]>;
+    readonly $capabilities: import("@angular/core").WritableSignal<string[]>;
+    readonly $egress: import("@angular/core").WritableSignal<string[]>;
+    /**
+     * Destinations derived from this configuration's own `x-egress-target` values. Taken from the saved
+     * configuration rather than recomputed locally, so the list matches what GZAC pushed to the host.
+     */
+    readonly $derivedEgress: import("@angular/core").WritableSignal<string[]>;
+    readonly $permissionsValid: import("@angular/core").WritableSignal<boolean>;
+    readonly $hasPermissionsStep: import("@angular/core").WritableSignal<boolean>;
+    readonly $definitionName: import("@angular/core").WritableSignal<string>;
+    readonly $awaitingHost: import("@angular/core").WritableSignal<boolean>;
+    currentStepIndex: number;
+    progressSteps: Array<{
+        label: string;
+        complete: boolean;
+    }>;
+    private _iframeConfigTitle;
+    private _iframeConfigData;
+    private readonly _$configurationSchema;
+    private readonly _$iframeValid;
+    private readonly _$definition;
+    private readonly _subscriptions;
+    private _propertiesValueSubscription;
+    constructor(_externalPluginService: ExternalPluginService, _translateService: TranslateService);
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    goToNextStep(): void;
+    onSave(): void;
+    onDelete(): void;
+    onClose(): void;
+    onIframeConfigurationChanged(event: {
+        valid: boolean;
+        title: string;
+        data: Record<string, unknown>;
+    }): void;
+    onPermissionsValid(valid: boolean): void;
+    get configValid(): boolean;
+    private _saveFromIframe;
+    private _initForm;
+    private _setDefinition;
+    private _updateDefinitionName;
+    private _resolveConfigBundleUrl;
+    /**
+     * Carbon's progress indicator recomputes step completion only inside its `current` setter, so a
+     * rebuilt steps array (language change, permissions step appearing) must carry the `complete`
+     * flags itself — with an unchanged current step the rebuild would otherwise wipe the checkmarks.
+     */
+    private _buildProgressSteps;
+    private _resetForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginExternalEditModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PluginExternalEditModalComponent, "valtimo-plugin-external-edit-modal", never, { "open": { "alias": "open"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; }, { "closeEvent": "closeEvent"; "savedEvent": "savedEvent"; "deleteEvent": "deleteEvent"; }, never, never, true, never>;
+}