@c8y/ngx-components 1023.0.0 → 1023.4.1

package/ai/agent-chat/index.d.ts

@@ -0,0 +1,114 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, Type, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ClientAgentDefinition, ToolResult, AIMessageStreamSteps, AgentStep, AIMessage } from '@c8y/ngx-components/ai';
+import { BehaviorSubject, OperatorFunction } from 'rxjs';
+
+declare class AgentChatComponent implements OnInit, OnDestroy {
+    agent: string | ClientAgentDefinition;
+    suggestions: {
+        label: string;
+        prompt: string;
+        icon?: string;
+    }[];
+    title: string;
+    headline: string;
+    welcomeText: string;
+    autoInstallAgents: boolean;
+    variables: {};
+    stepRenderComponent: Type<any>;
+    onMessageDelta: EventEmitter<string>;
+    onMessageText: EventEmitter<string>;
+    onMessageFinish: EventEmitter<string>;
+    onToolResult: EventEmitter<ToolResult>;
+    isLoading: boolean;
+    /**
+     * A stream of AI messages representing the conversation.
+     */
+    messages$: BehaviorSubject<AIMessageStreamSteps[]>;
+    agentName: string;
+    hasError: boolean;
+    canCreate: boolean;
+    errorMsg: string;
+    prompt: string;
+    private aiService;
+    private gainsightService;
+    private alertService;
+    private abortController;
+    private assistantSubscription;
+    defaultAgentStepRendererPipe: OperatorFunction<AgentStep[], {
+        content: Type<any> | string;
+        origin: AgentStep;
+    }[]>;
+    ngOnInit(): Promise<void>;
+    sendMessage(message: AIMessage): Promise<void>;
+    ngOnDestroy(): void;
+    reprompt(userMessage: AIMessageStreamSteps): void;
+    rate(assistantMessage: AIMessageStreamSteps, positive: any): void;
+    reload(assistantMessage: AIMessageStreamSteps): void;
+    cancel(): void;
+    createAgent(): Promise<void>;
+    private composeErrorMessage;
+    private processAgentMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AgentChatComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AgentChatComponent, "c8y-agent-chat", never, { "agent": { "alias": "agent"; "required": true; }; "suggestions": { "alias": "suggestions"; "required": false; }; "title": { "alias": "title"; "required": false; }; "headline": { "alias": "headline"; "required": false; }; "welcomeText": { "alias": "welcomeText"; "required": false; }; "autoInstallAgents": { "alias": "autoInstallAgents"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; "stepRenderComponent": { "alias": "stepRenderComponent"; "required": false; }; }, { "onMessageDelta": "onMessageDelta"; "onMessageText": "onMessageText"; "onMessageFinish": "onMessageFinish"; "onToolResult": "onToolResult"; }, never, never, true, never>;
+}
+
+declare class AgentStepFeedbackComponent implements OnInit, OnChanges {
+    step: AgentStep;
+    label: string;
+    loading: boolean;
+    collapsed: boolean;
+    canCollapse: boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    parseDefaultAgentStep(step: AgentStep): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AgentStepFeedbackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AgentStepFeedbackComponent, "c8y-agent-step-feedback", never, { "step": { "alias": "step"; "required": true; }; "label": { "alias": "label"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "canCollapse": { "alias": "canCollapse"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class WidgetAiChatSectionComponent implements OnInit {
+    suggestions: Array<{
+        label: string;
+        prompt: string;
+    }>;
+    agent: string | ClientAgentDefinition;
+    headline: "Welcome!";
+    title: string;
+    welcomeText: any;
+    variables: {
+        [key: string]: any;
+    };
+    useContextAsVariable: boolean;
+    contextVariableName: string;
+    _renderStepComponent: Type<any>;
+    private readonly widgetConfigService;
+    private readonly alertService;
+    private readonly contextRouteService;
+    /**
+     * A component that is used to render each step in the chat. By default, it uses the `AgentStepFeedbackComponent`.
+     * You can provide your own component by returning it from this callback.
+     *
+     * @returns A promise that resolves to a component type.
+     */
+    loadRenderStepComponent: () => Promise<Type<any>>;
+    /**
+     * A callback that is invoked when a tool result is returned. The function can return either:
+     * - `undefined` or `void`: No action is taken.
+     * - an object which is stored to the widget configuration.
+     */
+    onToolResult: (step: ToolResult) => undefined | any;
+    /**
+     * @ignore
+     */
+    ngOnInit(): Promise<void>;
+    /**
+     * Handles the tool result returned from the AI agent.
+     * @param tool The tool result returned from the AI agent.
+     */
+    toolResultHandler(tool: ToolResult): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetAiChatSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetAiChatSectionComponent, "c8y-widget-ai-chat-section", never, { "suggestions": { "alias": "suggestions"; "required": false; }; "agent": { "alias": "agent"; "required": false; }; "headline": { "alias": "headline"; "required": false; }; "title": { "alias": "title"; "required": false; }; "welcomeText": { "alias": "welcomeText"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; "useContextAsVariable": { "alias": "useContextAsVariable"; "required": false; }; "contextVariableName": { "alias": "contextVariableName"; "required": false; }; "loadRenderStepComponent": { "alias": "loadRenderStepComponent"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { AgentChatComponent, AgentStepFeedbackComponent, WidgetAiChatSectionComponent };
+//# sourceMappingURL=index.d.ts.map

package/ai/agent-chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../ai/agent-chat/agent-chat.component.ts","../../../ai/agent-chat/agent-step-feedback.component.ts","../../../ai/agent-chat/widget-ai-chat-section.component.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;;AAsCA,cAAA,kBAAA,YAAA,MAAA,EAAA,SAAA;AAiB6B,oBAAA,qBAAA;AAClB;;;;AAA6D;;;;AAI7D;AACA;AACA,yBAAA,IAAA;AAEC,oBAAA,YAAA;AACA,mBAAA,YAAA;AACA,qBAAA,YAAA;AACA,kBAAA,YAAA,CAAA,UAAA;AAEV;AAEA;;AAEG;AACH,eAAA,eAAA,CAAA,oBAAA;;AAIA;AACA;AACA;AACA;;;;;;AAQA,kCAAA,gBAAA,CAAA,SAAA;AAEI,iBAAA,IAAA;;AAAgD;AAc9C,gBAAA,OAAA;;AAgDN;;AAYA,2BAAA,oBAAA;;;;AA6CA;AAoCA;;;AAyCD;;ACjRD,cAAA,0BAAA,YAAA,MAAA,EAAA,SAAA;;;AAsBW;AACA;AACA;AAET;AAMA,yBAAA,aAAA;AAMA,gCAAA,SAAA;;;AAoBD;;AC5DD,cAAA,4BAAA,YAAA,MAAA;;;;AAQsD;AAEpD,oBAAA,qBAAA;AAEA;;AAIA;AAEA;AAAa;;AAEb;AAEA;AACA,0BAAA,IAAA;AAEA;AACA;AACA;AAEA;;;;;AAKG;;AAKH;;;;AAIG;;AAGH;;AAEG;AACG,gBAAA,OAAA;AAWN;;;AAGG;;;;AAoBJ;;;;"}

package/ai/ai-chat/index.d.ts

@@ -0,0 +1,145 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, QueryList } from '@angular/core';
+import { SupportedIconsSuggestions } from '@c8y/ngx-components/icon-selector/icons';
+import { AIMessage, ChatConfig } from '@c8y/ngx-components/ai';
+
+/**
+ * An action button that can be added to chat messages.
+ * Typically used for actions like copying, regenerating, or providing feedback on messages.
+ */
+declare class AiChatMessageActionComponent {
+    /**
+     * Disables the action button when true.
+     */
+    disabled: boolean;
+    /**
+     * Tooltip text displayed when hovering over the action button.
+     */
+    tooltip: string;
+    /**
+     * Icon to display in the action button.
+     */
+    icon: SupportedIconsSuggestions;
+    /**
+     * Emitted when the action button is clicked.
+     */
+    click: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiChatMessageActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AiChatMessageActionComponent, "c8y-ai-chat-message-action", never, { "disabled": { "alias": "disabled"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, { "click": "click"; }, never, never, true, never>;
+}
+
+declare class AiChatMessageComponent {
+    readonly role: i0.InputSignal<"user" | "assistant">;
+    readonly message: i0.InputSignal<AIMessage>;
+    private readonly translateService;
+    private readonly roleResolved;
+    /**
+     * Generates an accessible label for the message container.
+     * Includes the role (user or assistant) and timestamp if available.
+     * @returns The aria-label string for screen readers
+     */
+    readonly ariaLabel: i0.Signal<any>;
+    /**
+     * Generates an accessible label for the message content.
+     * Prefixes the content with contextual information about who sent it.
+     * @returns The aria-label string with prefixed role information
+     */
+    readonly messageContentAriaLabel: i0.Signal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiChatMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AiChatMessageComponent, "c8y-ai-chat-message", never, { "role": { "alias": "role"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, [":not(c8y-ai-chat-message-action)", "c8y-ai-chat-message-action"], true, never>;
+}
+
+/**
+ * A suggestion chip that can be displayed in the chat interface.
+ * When clicked, it automatically populates and sends a predefined prompt.
+ */
+declare class AiChatSuggestionComponent {
+    /**
+     * The visible label text displayed on the suggestion chip.
+     */
+    label: string;
+    /**
+     * The prompt text that will be sent when the suggestion is clicked.
+     */
+    prompt: string;
+    /**
+     * Icon to display alongside the suggestion label.
+     */
+    icon: SupportedIconsSuggestions;
+    /**
+     * When true, uses AI-styled buttons instead of default styling.
+     */
+    useAiButtons: boolean;
+    /**
+     * Disables the suggestion chip when true.
+     */
+    disabled: boolean;
+    /**
+     * Emitted when the suggestion is clicked, providing the prompt as an AIMessage.
+     */
+    suggestionClicked: EventEmitter<AIMessage>;
+    /**
+     * Handles suggestion click and emits the prompt as a user message.
+     */
+    suggest(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiChatSuggestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AiChatSuggestionComponent, "c8y-ai-chat-suggestion", never, { "label": { "alias": "label"; "required": false; }; "prompt": { "alias": "prompt"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "useAiButtons": { "alias": "useAiButtons"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "suggestionClicked": "suggestionClicked"; }, never, never, true, never>;
+}
+
+/**
+ * An interactive chat interface component for AI-powered conversations.
+ * Displays messages in a conversation format with support for loading states,
+ * custom configuration, and markdown formatting.
+ */
+declare class AiChatComponent {
+    /**
+     * Indicates whether the chat is currently processing a request.
+     * When true, displays a cancel button instead of send button and disables the input.
+     */
+    isLoading: boolean;
+    /**
+     * Disables the chat input and send button when true.
+     */
+    disabled: boolean;
+    /**
+     * The current text in the chat input field. Supports two-way binding.
+     */
+    prompt: string;
+    /**
+     * Emitted when the user sends a message.
+     * Provides an AIMessage object with role, content, and timestamp.
+     */
+    onMessage: EventEmitter<AIMessage>;
+    /**
+     * Emitted when the user cancels an ongoing operation during loading state.
+     */
+    onCancel: EventEmitter<void>;
+    /**
+     * Child message components displayed in the chat.
+     */
+    messages: QueryList<AiChatMessageComponent>;
+    readonly componentId: string;
+    private _config;
+    /**
+     * Configuration object for customizing labels, placeholders, and icons.
+     * Accepts partial configuration to override defaults.
+     */
+    set config(value: Partial<ChatConfig>);
+    get config(): Partial<ChatConfig>;
+    /**
+     * Handles message submission when the user sends a message.
+     * Emits the onMessage event and clears the input.
+     * @param $event - The event object from the form submission
+     */
+    sendMessage($event: Event): void;
+    /**
+     * Handles cancellation of ongoing operations during loading state.
+     * Emits the onCancel event.
+     */
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiChatComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AiChatComponent, "c8y-ai-chat", never, { "isLoading": { "alias": "isLoading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "prompt": { "alias": "prompt"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "onMessage": "onMessage"; "onCancel": "onCancel"; }, ["messages"], ["c8y-ai-chat-message", "*", "c8y-ai-chat-suggestion"], true, never>;
+}
+
+export { AiChatComponent, AiChatMessageActionComponent, AiChatMessageComponent, AiChatSuggestionComponent };
+//# sourceMappingURL=index.d.ts.map

package/ai/ai-chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../ai/ai-chat/ai-chat-message-action.component.ts","../../../ai/ai-chat/ai-chat-message.component.ts","../../../ai/ai-chat/ai-chat-suggestion.component.ts","../../../ai/ai-chat/ai-chat.component.ts"],"sourcesContent":[null,null,null,null],"names":["_angular_core"],"mappings":";;;;;AAKA;;;AAGG;AACH,cAAA,4BAAA;AAOE;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;;AAIH;;AAEG;AAEH,WAAA,YAAA;;;AACD;;AC/BD,cAAA,sBAAA;mBAOeA,EAAA,CAAA,WAAA;sBACGA,EAAA,CAAA,WAAA,CAAA,SAAA;AAChB;AAEA;AAIA;;;;AAIG;wBACeA,EAAA,CAAA,MAAA;AASlB;;;;AAIG;sCAC6BA,EAAA,CAAA,MAAA;;;AAcjC;;ACnDD;;;AAGG;AACH,cAAA,yBAAA;AAOE;;AAEG;;AAIH;;AAEG;;AAIH;;AAEG;;AAIH;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;AAEH,uBAAA,YAAA,CAAA,SAAA;AAEA;;AAEG;;;;AAQJ;;ACtDD;;;;AAIG;AACH,cAAA,eAAA;AAQE;;;AAGG;AAEH;AAEA;;AAEG;AAEH;AAEA;;AAEG;AAEH;AAEA;;;AAGG;AAEH,eAAA,YAAA,CAAA,SAAA;AAEA;;AAEG;AAEH,cAAA,YAAA;AAEA;;AAEG;AACsC,cAAA,SAAA,CAAA,sBAAA;;;AAoBzC;;;AAGG;;AAKH,kBAAA,OAAA,CAAA,UAAA;AAIA;;;;AAIG;AACH,wBAAA,KAAA;AAWA;;;AAGG;AACH;;;AAGD;;;;"}

package/ai/index.d.ts

@@ -0,0 +1,203 @@
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FetchClient } from '@c8y/client';
+
+interface AIMessageStreamSteps extends AIMessage {
+    componentSteps$?: Observable<{
+        content: Type<any> | string;
+        origin: AgentStep;
+    }[]>;
+}
+interface AIMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    options?: AIMessageOptions;
+    steps?: Array<AgentStep>;
+    finishReason?: 'stop' | 'error' | 'tool_use';
+    timestamp?: string;
+}
+interface AIMessageOptions {
+    skipToLLM?: boolean;
+    hiddenContent?: string;
+    variables?: {
+        [key: string]: any;
+    };
+}
+declare enum DataStreamType {
+    TEXT_DELTA = "text-delta",
+    TOOL_CALL = "tool-call",
+    TOOL_CALL_STREAMING = "tool-call-streaming",
+    TOOL_CALL_DELTA = "tool-call-delta",
+    TOOL_RESULT = "tool-result",
+    REASONING = "reasoning",
+    REASONING_DELTA = "reasoning-delta",
+    REDACTED_REASONING = "redacted-reasoning",
+    REASONING_SIGNATURE = "reasoning-signature",
+    FINISH_REASONING = "finish-reasoning",
+    FINISH = "finish",
+    FINISH_STEP = "finish-step",
+    ERROR = "error",
+    DATA = "data",
+    MESSAGE_ANNOTATIONS = "message-annotations",
+    SOURCE = "source",
+    FILE = "file",
+    STEP_START = "step-start",
+    STEP_FINISH = "step-finish"
+}
+type AgentStep = {
+    type: 'text' | 'reasoning' | string;
+    text: string;
+    reasoning?: string;
+    textDelta?: string;
+    toolCalls?: Array<ToolCall>;
+    toolResults?: Array<ToolResult>;
+};
+interface Tool {
+    toolName: string;
+    toolId: string;
+    type: 'tool-call' | 'tool-result';
+}
+interface ToolCall extends Tool {
+    arguments: {
+        [key: string]: any;
+    };
+}
+interface ToolResult extends Tool {
+    result: {
+        content: {
+            text: string;
+            type: string;
+        }[];
+    };
+}
+interface ClientAgentDefinition {
+    /**
+     * If set to true, the agent will be created each time. This is useful for development.
+     */
+    snapshot: boolean;
+    /**
+     * The label of the agent that is shown to the user.
+     */
+    label: string;
+    /**
+     * The definitions of the agent.
+     *
+     * You can use multiple definitions that can be used in an agent-2-agent scenario
+     * The first definition is the entry point.
+     */
+    definitions: {
+        name: string;
+        type: 'object' | 'text';
+        agent: {
+            system: string;
+            [key: string]: any;
+        };
+        mcp: Array<{
+            serverName: string;
+            tools: string[];
+        }>;
+    }[];
+}
+interface ChatConfig {
+    title: string;
+    headline: string;
+    welcomeText: string;
+    placeholder: string;
+    sendButtonText: string;
+    cancelButtonText: string;
+    disclaimerText: string;
+    userInterfaceIcons: {
+        send: string;
+        cancel: string;
+    };
+}
+interface AgentHealthCheckResponse {
+    /**
+     * Indicates if the agent exists and can be used.
+     * If false, the agent was not found.
+     */
+    exists: boolean;
+    /**
+     * Indicates if the user can create the agent, and if a global provider is configured.
+     */
+    canCreate: boolean;
+    /**
+     * Indicates if the provider is configured.
+     * If false, the agent cannot be created as the provider is not configured.
+     */
+    isProviderConfigured: boolean;
+    /**
+     * If canCreate or exist is false, this array contains messages
+     * that explain why the agent cannot be used or created.
+     */
+    messages?: string[];
+}
+
+declare class AIService {
+    private client;
+    private baseUrl;
+    constructor(client: FetchClient);
+    createOrUpdateAgent(agentsDef: ClientAgentDefinition): Promise<void>;
+    /**
+     * Check if an agent exists.
+     * @param name Agent name
+     * @returns Agent health check response.
+     */
+    getAgentHealth(name: string): Promise<AgentHealthCheckResponse>;
+    /**
+     * Send a text message to the agent.
+     * @param name Agent name
+     * @param messages Messages to send
+     * @param variables Variables to include
+     * @returns Text response from the agent.
+     */
+    text(name: string, messages: AIMessage[], variables: {
+        [key: string]: any;
+    }): Promise<string>;
+    /**
+     * Stream a text message to the agent.
+     * @param agentName Agent name
+     * @param messages Messages to send
+     * @param variables Variables to include
+     * @param abortController An AbortController to cancel the request.
+     * @returns An observable that emits partial AIMessage objects as they are received. The observable can be cancelled using the provided AbortController.
+     * The observable will emit an error if the request fails or is aborted.
+     * The observable will complete when the stream is finished.
+     *
+     * The messages sent to the agent can include special options:
+     * - `hiddenContent`: If set, this content will be sent to the agent instead of the `content` field.
+     * - `skipToLLM`: If set to true, this message will be skipped when sending to the agent.
+     *
+     * Example usage:
+     * ```typescript
+     * const abortController = new AbortController();
+     * const messages: AIMessage[] = [
+     *   { role: 'user', content: 'Hello' },
+     *   { role: 'assistant', content: 'Hi there!' },
+     *   { role: 'user', content: 'Tell me a joke.', options: { hiddenContent: 'Tell me a joke about cats.' } }
+     * ];
+     * const observable = aiService.stream$('my-agent', messages, {}, abortController);
+     * const subscription = observable.subscribe({
+     *   next: (message) => console.log('Received message part:', message),
+     *   error: (err) => console.error('Error:', err),
+     *   complete: () => console.log('Stream complete')
+     * });
+     *
+     * // To cancel the request:
+     * abortController.abort();
+     * subscription.unsubscribe();
+     * ```
+     */
+    stream$(agentName: string, messages: AIMessage[], variables: {
+        [key: string]: any;
+    }, abortController: AbortController): Promise<Observable<AIMessage>>;
+    private parseMessages;
+    private processLine;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AIService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AIService>;
+}
+
+export { AIService, DataStreamType };
+export type { AIMessage, AIMessageOptions, AIMessageStreamSteps, AgentHealthCheckResponse, AgentStep, ChatConfig, ClientAgentDefinition, Tool, ToolCall, ToolResult };
+//# sourceMappingURL=index.d.ts.map

package/ai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../ai/ai.model.ts","../../ai/ai.service.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;AAGM;;AAC2B;;AAAgD;AAChF;;AAGC;;;AAGA;AACA;;AAED;;;;AAKC;AAAc;;AACf;AAED;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACD;AAEK;AACJ;;;;AAIA;AACA;;;;;AAMA;AACD;AAEK;AACJ;AAAa;;AACd;AAEK;AACJ;AACE;;;AAGC;;AAEJ;;AAGC;;AAEG;;AAEH;;AAEG;;AAEH;;;;;AAKG;AACH;;AAEE;AACA;;AAEE;;;;;AAEgD;AACnD;AACF;;;;;;;;;AAUC;;;;AACD;;AAGC;;;AAGG;;AAEH;;AAEG;;AAEH;;;AAGG;;AAEH;;;AAGG;AACH;AACD;;ACvHD;AAMc;;AAAQ;;AAuBpB;;;;AAIG;;AAkBH;;;;;;AAMG;;AAIY;;AAkBf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;;AAIY;;AAyEf;AAiBA;;;AA6ED;;;"}

package/context-dashboard/device/add/index.d.ts

@@ -1,5 +1,7 @@
 import * as i0 from '@angular/core';
 import * as i1 from '@c8y/ngx-components/context-dashboard';
+import { AddDashboardFactory, DashboardActionBarFactory } from '@c8y/ngx-components/context-dashboard';
+import { ViewContext } from '@c8y/ngx-components';
 
 declare class AddDeviceContextDashboardModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<AddDeviceContextDashboardModule, never>;
@@ -7,5 +9,17 @@ declare class AddDeviceContextDashboardModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<AddDeviceContextDashboardModule>;
 }
 
-export { AddDeviceContextDashboardModule };
+declare class AddDeviceDashboardFactory extends AddDashboardFactory {
+    protected targetContext: ViewContext.Device | ViewContext.Group;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddDeviceDashboardFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AddDeviceDashboardFactory>;
+}
+
+declare class DeviceDashboardActionBarFactory extends DashboardActionBarFactory {
+    protected targetContext: ViewContext.Device | ViewContext.Group;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceDashboardActionBarFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceDashboardActionBarFactory>;
+}
+
+export { AddDeviceContextDashboardModule, AddDeviceDashboardFactory, DeviceDashboardActionBarFactory };
 //# sourceMappingURL=index.d.ts.map

package/context-dashboard/device/add/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sources":["../../../../context-dashboard/device/add/add-device-context-dashboard.module.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAkBA,cAAA,+BAAA;;;;AAkB+C;;;;"}
+{"version":3,"file":"index.d.ts","sources":["../../../../context-dashboard/device/add/add-device-context-dashboard.module.ts","../../../../context-dashboard/device/add/add-device-dashboard.factory.ts","../../../../context-dashboard/device/add/device-dashboard-action-bar.factory.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;;AAkBA,cAAA,+BAAA;;;;AAkB+C;;AChC/C,cAAA,yBAAA,SAAA,mBAAA;;;;AAKC;;ACLD,cAAA,+BAAA,SAAA,yBAAA;;;;AAKC;;;;"}

package/context-dashboard/device/view/index.d.ts

@@ -1,5 +1,17 @@
-import * as i0 from '@angular/core';
+import { ActivatedRouteSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+import { Tab } from '@c8y/ngx-components';
 import * as i1 from '@c8y/ngx-components/context-dashboard';
+import { ContextDashboardService } from '@c8y/ngx-components/context-dashboard';
+import * as i0 from '@angular/core';
+
+declare class DeviceDashboardGuard {
+    private contextDashboardService;
+    constructor(contextDashboardService: ContextDashboardService);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean | Tab[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceDashboardGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceDashboardGuard>;
+}
 
 declare class ViewDeviceContextDashboardModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ViewDeviceContextDashboardModule, never>;
@@ -7,5 +19,5 @@ declare class ViewDeviceContextDashboardModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<ViewDeviceContextDashboardModule>;
 }
 
-export { ViewDeviceContextDashboardModule };
+export { DeviceDashboardGuard, ViewDeviceContextDashboardModule };
 //# sourceMappingURL=index.d.ts.map

package/context-dashboard/device/view/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sources":["../../../../context-dashboard/device/view/view-device-context-dashboard.module.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA,cAAA,gCAAA;;;;AAegD;;;;"}
+{"version":3,"file":"index.d.ts","sources":["../../../../context-dashboard/device/view/device-dashboard.guard.ts","../../../../context-dashboard/device/view/view-device-context-dashboard.module.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;;;AASA,cAAA,oBAAA;AAEc;AAAQ,yCAAA,uBAAA;;;;AAQrB;;ACVD,cAAA,gCAAA;;;;AAegD;;;;"}

package/context-dashboard/devicemanagement/index.d.ts

@@ -0,0 +1,10 @@
+import * as _angular_core from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare const DM_DASHBOARD_MANAGER_PREVIEW_KEY = "ui.dm-dashboard-manager";
+declare function canActivateDashboardManager(): Observable<boolean>;
+declare const addDeviceContextDashboardFeatureProvider: (_angular_core.EnvironmentProviders | _angular_core.ValueProvider | _angular_core.ClassProvider | _angular_core.ExistingProvider)[];
+declare const viewDeviceContextDashboardFeatureProvider: (_angular_core.EnvironmentProviders | _angular_core.ValueProvider | _angular_core.ClassProvider | _angular_core.ExistingProvider)[];
+
+export { DM_DASHBOARD_MANAGER_PREVIEW_KEY, addDeviceContextDashboardFeatureProvider, canActivateDashboardManager, viewDeviceContextDashboardFeatureProvider };
+//# sourceMappingURL=index.d.ts.map

package/context-dashboard/devicemanagement/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../context-dashboard/devicemanagement/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAqBA,cAAA,gCAAA;AAEA,iBAAA,2BAAA,IAAA,UAAA;AAKA,cAAA,wCAAA,GAAqD,aAAA,CAAA,oBAAA,GAAA,aAAA,CAAA,aAAA,GAAA,aAAA,iBAAA,aAAA,CAAA,gBAAA;AAiBrD,cAAA,yCAAA,GAAsD,aAAA,CAAA,oBAAA,GAAA,aAAA,CAAA,aAAA,GAAA,aAAA,iBAAA,aAAA,CAAA,gBAAA;;;;"}

package/context-dashboard/index.d.ts

@@ -63,22 +63,6 @@ interface ContextDashboardConfig {
      */
     routes?: Route[];
 }
-/**
- * Defines how the widget configuration is changed.
- */
-declare const WidgetConfigChangeMode: {
-    /**
-     * The properties are assigned, the config object instance remains the same.
-     * This is used for legacy widgets, which are using the config object to exchange data.
-     * You should use `EMIT` for new widgets and listen to the `currentConfig$` observable.
-     */
-    readonly ASSIGN: "ASSIGN";
-    /**
-     * A new config object is emitted on each change.
-     */
-    readonly EMIT: "EMIT";
-};
-type WidgetConfigChangeMode = (typeof WidgetConfigChangeMode)[keyof typeof WidgetConfigChangeMode];
 interface ContextWidgetConfig {
     /**
      * Settings that define how the default config component is
@@ -393,6 +377,7 @@ declare class ContextDashboardService {
     private groupService;
     private optionsService;
     private appStateService;
+    private contextRouteService;
     dashboardTabs$: Observable$1<Tab[]>;
     formDisabled$: Observable$1<boolean>;
     readonly REPORT_PARTIAL_NAME = "report_";
@@ -414,7 +399,7 @@ declare class ContextDashboardService {
     private readonly HIDE_TYPE_DASHBOARD_FOR_ASSETS;
     get formDisabled(): boolean;
     set formDisabled(value: boolean);
-    constructor(inventory: InventoryService, tabs: TabsService, modal: ModalService, translateService: TranslateService, router: Router, navigator: NavigatorService, permissions: Permissions, alert: AlertService, dynamicComponent: DynamicComponentService, groupService: GroupService, optionsService: OptionsService, appStateService: AppStateService);
+    constructor(inventory: InventoryService, tabs: TabsService, modal: ModalService, translateService: TranslateService, router: Router, navigator: NavigatorService, permissions: Permissions, alert: AlertService, dynamicComponent: DynamicComponentService, groupService: GroupService, optionsService: OptionsService, appStateService: AppStateService, contextRouteService: ContextRouteService);
     create(dashboardCfg: ContextDashboard, context?: ContextData, name?: string): Promise<ContextDashboardManagedObject>;
     detail(dashboardMO: ContextDashboardManagedObject): Promise<IManagedObject>;
     update(dashboard: ContextDashboardManagedObject, context?: ContextData): Promise<ContextDashboardManagedObject>;
@@ -906,6 +891,8 @@ declare class ContextDashboardComponent implements OnInit, OnDestroy, CanDeactiv
      * Hides dashboard availability selection.
      */
     hideAvailability: boolean;
+    /** Explicitly set the dashboard in `disabled` state, e.g. to create read-only dashboard */
+    isDisabled: i0.InputSignal<boolean>;
     class: string;
     dashboardDetails: DashboardDetailComponent;
     widgetsDashboard: WidgetsDashboardComponent;
@@ -1032,7 +1019,7 @@ declare class ContextDashboardComponent implements OnInit, OnDestroy, CanDeactiv
     private extractDefaultDashboardName;
     private convertStringToHash;
     static ɵfac: i0.ɵɵFactoryDeclaration<ContextDashboardComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ContextDashboardComponent, "c8y-context-dashboard", never, { "name": { "alias": "name"; "required": false; }; "childrenClasses": { "alias": "childrenClasses"; "required": false; }; "context": { "alias": "context"; "required": false; }; "setTitle": { "alias": "setTitle"; "required": false; }; "defaultWidgets": { "alias": "defaultWidgets"; "required": false; }; "_canCopy": { "alias": "canCopy"; "required": false; }; "canDelete": { "alias": "canDelete"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "breadcrumbSettings": { "alias": "breadcrumbSettings"; "required": false; }; "showContextHelpButton": { "alias": "showContextHelpButton"; "required": false; }; "translateWidgetTitle": { "alias": "translateWidgetTitle"; "required": false; }; "translateDashboardTitle": { "alias": "translateDashboardTitle"; "required": false; }; "hideAvailability": { "alias": "hideAvailability"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextDashboardComponent, "c8y-context-dashboard", never, { "name": { "alias": "name"; "required": false; }; "childrenClasses": { "alias": "childrenClasses"; "required": false; }; "context": { "alias": "context"; "required": false; }; "setTitle": { "alias": "setTitle"; "required": false; }; "defaultWidgets": { "alias": "defaultWidgets"; "required": false; }; "_canCopy": { "alias": "canCopy"; "required": false; }; "canDelete": { "alias": "canDelete"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "breadcrumbSettings": { "alias": "breadcrumbSettings"; "required": false; }; "showContextHelpButton": { "alias": "showContextHelpButton"; "required": false; }; "translateWidgetTitle": { "alias": "translateWidgetTitle"; "required": false; }; "translateDashboardTitle": { "alias": "translateDashboardTitle"; "required": false; }; "hideAvailability": { "alias": "hideAvailability"; "required": false; }; "isDisabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class AppearanceSettingsComponent {
@@ -1199,7 +1186,6 @@ interface WidgetConfigSectionBase<T> {
 declare class WidgetConfigSectionService extends ExtensionPointForPlugins<WidgetConfigSectionDefinition> {
     private router;
     private plugins;
-    private readonly DEFAULT_WAIT_TIME;
     constructor(rootInjector: Injector, router: Router, plugins: PluginsResolveService);
     get state(): Set<WidgetConfigSectionDefinition<any>>;
     add(component: WidgetConfigSectionDefinition): void;
@@ -1232,16 +1218,6 @@ declare class WidgetConfigService {
      * The currently selected widget component.
      */
     selectedComponent$: BehaviorSubject<DynamicComponentComponent>;
-    /**
-     * The mode of handling changes in the widget configuration.
-     * - `ASSIGN`: The configuration changes are assigned to the current configuration object.
-     * - `EMIT`: The configuration changes are emitted via the `updateConfig` method.
-     *
-     * Default is `EMIT`. The `ASSIGN` mode should be used for old widgets using the
-     * `@Input config` property to get the configuration. New widgets should use the
-     *  `updateConfig` and `currentConfig$` observable to set or get the configuration.
-     */
-    changeMode$: BehaviorSubject<WidgetConfigChangeMode>;
     /**
      * The current configuration of the selected widget.
      * Only to read the value. Use `updateConfig` to update the configuration.
@@ -1717,6 +1693,6 @@ declare class WidgetConfigFeedbackComponent implements AfterViewInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<WidgetConfigFeedbackComponent, "c8y-widget-config-feedback", never, {}, {}, never, ["*"], true, never>;
 }
 
-export { ALL_GLOBAL_ROLES_SELECTED, AddDashboardComponent, AddDashboardFactory, AppearanceSettingsComponent, CONTEXT_DASHBOARD_CONFIG, ContextDashboardComponent, ContextDashboardModule, ContextDashboardService, ContextDashboardType, DASHBOARD_CHILDREN_STATE_NAME, DASHBOARD_DETAILS_OUTLET, DASHBOARD_DETAILS_TABS_OUTLET_NAME, DASHBOARD_SETTINGS_CHANGES, DASHBOARD_THEME_CLASSES, DashboardActionBarFactory, DashboardDetailComponent, DashboardDetailService, DashboardDetailsTabId, DeviceInfoDashboardComponent, DeviceInfoDashboardModule, DeviceManagementHomeDashboardComponent, DeviceManagementHomeDashboardModule, GlobalContextSectionComponent, HOOK_WIDGET_CONFIG, NewDashboardGuard, PRODUCT_EXPERIENCE, PasteDashboardActionComponent, REPORT_DEFAULT_NAVIGATION_NODE_PRIORITY, STYLING_CLASS_PREFIXES, TypeDashboardInfoComponent, WIDGET_CONTENT_CLASSES, WIDGET_HEADER_CLASSES, WidgetAssetSelectorComponent, WidgetConfigAppearanceComponent, WidgetConfigChangeMode, WidgetConfigComponent, WidgetConfigFeedbackComponent, WidgetConfigGeneralComponent, WidgetConfigSectionComponent, WidgetConfigSectionService, WidgetConfigService, WidgetPreviewComponent, WidgetPreviewWrapperComponent, WidgetService, hookWidgetConfig, newDashboardTab };
+export { ALL_GLOBAL_ROLES_SELECTED, AddDashboardComponent, AddDashboardFactory, AppearanceSettingsComponent, CONTEXT_DASHBOARD_CONFIG, ContextDashboardComponent, ContextDashboardModule, ContextDashboardService, ContextDashboardType, DASHBOARD_CHILDREN_STATE_NAME, DASHBOARD_DETAILS_OUTLET, DASHBOARD_DETAILS_TABS_OUTLET_NAME, DASHBOARD_SETTINGS_CHANGES, DASHBOARD_THEME_CLASSES, DashboardActionBarFactory, DashboardDetailComponent, DashboardDetailService, DashboardDetailsTabId, DeviceInfoDashboardComponent, DeviceInfoDashboardModule, DeviceManagementHomeDashboardComponent, DeviceManagementHomeDashboardModule, GlobalContextSectionComponent, HOOK_WIDGET_CONFIG, NewDashboardGuard, PRODUCT_EXPERIENCE, PasteDashboardActionComponent, REPORT_DEFAULT_NAVIGATION_NODE_PRIORITY, STYLING_CLASS_PREFIXES, TypeDashboardInfoComponent, WIDGET_CONTENT_CLASSES, WIDGET_HEADER_CLASSES, WidgetAssetSelectorComponent, WidgetConfigAppearanceComponent, WidgetConfigComponent, WidgetConfigFeedbackComponent, WidgetConfigGeneralComponent, WidgetConfigSectionComponent, WidgetConfigSectionService, WidgetConfigService, WidgetPreviewComponent, WidgetPreviewWrapperComponent, WidgetService, hookWidgetConfig, newDashboardTab };
 export type { AllowTypeDashboard, CanDeactivateComponent, ContextDashboard, ContextDashboardConfig, ContextDashboardManagedObject, ContextWidgetConfig, DashboardAndWidgetThemeDefinition, DashboardChildrenState, DashboardContext, DashboardCopyClipboard, DashboardDetailsTabs, DashboardGlobalRoles, DashboardHistoryDescription, DashboardMetadata, WidgetConfigSection, WidgetConfigSectionBase, WidgetConfigSectionDefinition, WidgetConfigSectionExtension };
 //# sourceMappingURL=index.d.ts.map