@lenne.tech/ng-base 18.1.2 → 22.0.0

package/types/lenne.tech-ng-base-ai.d.ts

@@ -0,0 +1,830 @@
+import * as i0 from "@angular/core";
+import { EnvironmentProviders, InjectionToken, Signal } from "@angular/core";
+/** Execution mode for a prompt. `auto` = reactive agent loop, `plan` = validate-all-then-execute. */
+type LtAiMode = 'auto' | 'plan';
+/**
+ * Input for a single AI run — sent to `POST /ai/prompt` | `POST /ai/stream`.
+ *
+ * Distinct from {@link LtAiPromptInput} (CRUD input for the user-facing
+ * `LtAiPrompt` entity). Pre-1.7.0 release builds called this type
+ * `LtAiPromptInput`; renamed to avoid a silent declaration merge with the
+ * CRUD input introduced for `LtAiPromptsService`.
+ */
+interface LtAiPromptRunInput {
+  /** Confirm execution of actions that required confirmation in a previous turn. */
+  confirm?: boolean;
+  /** Id of the connection to use (omit to let the backend resolution chain decide). */
+  connectionId?: string;
+  /** Conversation id for multi-turn continuation. */
+  conversationId?: string;
+  /** Structured context the assistant should consider. */
+  context?: Record<string, unknown>;
+  /** Untrusted client metadata (current URL, navigation, console logs) for enrichment. */
+  metadata?: Record<string, unknown>;
+  /** Execution mode (defaults to the backend's `ai.defaultMode`). */
+  mode?: LtAiMode;
+  /** The user's prompt text. */
+  prompt: string;
+  /** Override the admin default for requiring confirmation of mutating actions. */
+  requireConfirmation?: boolean;
+}
+/** A tool action executed (or planned/pending) during a run. */
+interface LtAiAction {
+  arguments?: Record<string, any>;
+  name: string;
+  result?: any;
+  success?: boolean;
+}
+/** Token usage of a single run (best effort). */
+interface LtAiUsage {
+  completionTokens?: number;
+  promptTokens?: number;
+  totalTokens?: number;
+}
+/** Compact token-budget summary attached to every response. */
+interface LtAiBudgetSummary {
+  /** Effective limit (user → tenant → LLM context window → null). Null = no limit. */
+  maxTokens?: number;
+  promptTokens?: number;
+  remainingTokens?: number;
+  resetAt?: string;
+  /** Which scope yielded maxTokens: 'user', 'tenant' or 'llm'. */
+  scope?: 'llm' | 'tenant' | 'user';
+  usedTokens?: number;
+}
+/** Structured response of a prompt run (`CoreAiResponse`). */
+interface LtAiResponse {
+  actions?: LtAiAction[];
+  budget?: LtAiBudgetSummary;
+  connectionId?: string;
+  /** Context-window utilization at the end of the run (used/total tokens). */
+  contextWindow?: {
+    total: number;
+    used: number;
+  };
+  conversationId?: string;
+  data?: any;
+  denied?: boolean;
+  deniedActions?: LtAiAction[];
+  iterations?: number;
+  pendingActions?: LtAiAction[];
+  pendingQuestion?: {
+    options?: {
+      label: string;
+      value: string;
+    }[];
+    question: string;
+  };
+  plan?: LtAiAction[];
+  requiresConfirmation?: boolean;
+  text: string;
+  usage?: LtAiUsage;
+}
+/** Server-sent event emitted by `POST /ai/stream`. */
+type LtAiStreamEvent = {
+  action: LtAiAction;
+  type: 'action';
+} | {
+  message: string;
+  type: 'error';
+} | {
+  response: LtAiResponse;
+  type: 'final';
+} | {
+  token: string;
+  type: 'token';
+};
+/** Callbacks for {@link LtAiState.promptStream}. */
+interface LtAiStreamHandlers {
+  onAction?: (action: LtAiAction) => void;
+  onError?: (message: string) => void;
+  onEvent?: (event: LtAiStreamEvent) => void;
+  onFinal?: (response: LtAiResponse) => void;
+  onToken?: (token: string) => void;
+}
+/** A single chat message in {@link LtAiChatState}. */
+interface LtAiMessage {
+  actions?: LtAiAction[];
+  budget?: LtAiBudgetSummary;
+  content: string;
+  createdAt?: string;
+  denied?: boolean;
+  error?: boolean;
+  /** Pending actions awaiting confirmation (assistant turns only). */
+  pendingActions?: LtAiAction[];
+  /** Whether this assistant turn is still streaming. */
+  pending?: boolean;
+  /** Whether this assistant turn awaits a confirmation to proceed. */
+  requiresConfirmation?: boolean;
+  role: 'assistant' | 'user';
+}
+/** A non-sensitive connection the current user/tenant may use. */
+interface LtAiAvailableConnection {
+  id: string;
+  isDefault?: boolean;
+  locked?: boolean;
+  model?: string;
+  name?: string;
+  selected?: boolean;
+}
+/** The current user's AI settings as they take effect (`GET/PUT /ai/settings`, nest-server >= 12.3.0). */
+interface LtAiSettings {
+  /** Whether MCP asks this user before a destructive tool (and a mutating one, if configured) runs. */
+  mcpConfirmation: boolean;
+  /** Whether the server fixed `mcpConfirmation`, so the user cannot change it (a change answers 403 `#LTNS_0609`). */
+  mcpConfirmationEnforced: boolean;
+}
+/** The user's own choices for `PUT /ai/settings`; a field left out stays unchanged. */
+interface LtAiSettingsInput {
+  mcpConfirmation?: boolean;
+}
+/** Whether the API's AI module is on (`GET /ai/status`), as `LtAiStatusService` holds it. */
+interface LtAiStatus {
+  /** True only after a well-formed 200: the AI module is on. */
+  enabled: boolean;
+  /** Why the status could not be read (network, timeout, other status, malformed body); null for an answer, 404 included. */
+  error: null | string;
+  /** True once an answer or an error is in. */
+  loaded: boolean;
+  /** Whether the API serves MCP; false whenever `enabled` is false. */
+  mcp: boolean;
+}
+/** Usage for a single scope (user or tenant). */
+interface LtAiUsageScope {
+  maxPrompts?: number;
+  maxTokens?: number;
+  period: string;
+  refId?: string;
+  remainingPrompts?: number;
+  remainingTokens?: number;
+  resetAt?: string;
+  scope: string;
+  usedPrompts: number;
+  usedTokens: number;
+}
+/** Full usage info (`GET /ai/usage`). */
+interface LtAiUsageInfo {
+  tenant?: LtAiUsageScope;
+  user?: LtAiUsageScope;
+}
+/** Admin view of a connection (`apiKey` is never returned — only `hasApiKey`). */
+interface LtAiConnection {
+  apiKeyEnv?: string;
+  baseUrl?: string;
+  capabilities?: string[];
+  defaultMaxTokens?: number;
+  defaultTemperature?: number;
+  description?: string;
+  enabled?: boolean;
+  enforced?: boolean;
+  enforcedTenantIds?: string[];
+  hasApiKey?: boolean;
+  id: string;
+  isDefault?: boolean;
+  model?: string;
+  name?: string;
+  providerType?: string;
+  supportsJsonResponse?: boolean;
+  supportsNativeTools?: boolean;
+  supportsVision?: boolean;
+  tenantIds?: string[];
+}
+/** Input to create/update a connection (`apiKey`: value sets, '' clears, omit leaves). */
+interface LtAiConnectionInput {
+  apiKey?: string;
+  apiKeyEnv?: string;
+  baseUrl?: string;
+  defaultMaxTokens?: number;
+  defaultTemperature?: number;
+  description?: string;
+  enabled?: boolean;
+  enforced?: boolean;
+  enforcedTenantIds?: string[];
+  isDefault?: boolean;
+  model?: string;
+  name?: string;
+  providerType?: string;
+  supportsJsonResponse?: boolean;
+  supportsNativeTools?: boolean;
+  supportsVision?: boolean;
+  tenantIds?: string[];
+}
+/** A tenant/user connection preference. */
+interface LtAiConnectionPreference {
+  connectionId: string;
+  enforced?: boolean;
+  id?: string;
+  refId: string;
+  scope: 'tenant' | 'user';
+}
+/** A per-user/per-tenant budget-limit override. */
+interface LtAiBudgetLimit {
+  id?: string;
+  maxPrompts?: number;
+  maxTokens?: number;
+  period?: 'day' | 'month' | 'none';
+  refId: string;
+  scope: 'tenant' | 'user';
+}
+/** An AI interaction audit record. */
+interface LtAiInteraction {
+  actions?: {
+    name: string;
+    success: boolean;
+  }[];
+  completionTokens?: number;
+  connectionId?: string;
+  createdAt?: string;
+  id: string;
+  iterations?: number;
+  prompt?: string;
+  promptTokens?: number;
+  responseText?: string;
+  tenantId?: string;
+  totalTokens?: number;
+  userId?: string;
+}
+/**
+ * An admin-editable AI slot — a logical building block of the SYSTEM prompt
+ * (e.g. `base`, `permissions`, `anti_hallucination`, `tool_catalog`).
+ * The backend ships built-in defaults for every key; a row here OVERRIDES the
+ * default for its `key` (optionally scoped by `locale`/`capability`).
+ * When multi-tenancy is active, slots are tenant-scoped.
+ */
+interface LtAiSlot {
+  /** Capability scope: 'all', 'native' or 'emulated'. */
+  capability?: string;
+  /** Slot text (supports {{placeholders}}). */
+  content: string;
+  createdAt?: string;
+  /** Admin-facing description of the slot. */
+  description?: string;
+  /** Whether the slot is included in the prompt. */
+  enabled?: boolean;
+  id: string;
+  /** Logical prompt slot key (e.g. 'base', 'permissions', 'anti_hallucination'). */
+  key: string;
+  /** Locale (e.g. 'en', 'de'); empty = all languages. */
+  locale?: string;
+  /** Assembly order (ascending). */
+  order?: number;
+  /** Tenant id the slot applies to (auto-set; undefined = system-wide). */
+  tenantId?: string;
+  updatedAt?: string;
+}
+/** Input to create/update an admin AI slot. */
+interface LtAiSlotInput {
+  capability?: string;
+  content?: string;
+  description?: string;
+  enabled?: boolean;
+  key?: string;
+  locale?: string;
+  order?: number;
+}
+/**
+ * Effective slot for the admin UI — framework defaults + tenant overrides +
+ * tenant customs in one list. The `isSystem` / `isOverride` flags drive which
+ * actions the UI renders:
+ *  - `isSystem: true`  → virtual default row (no `id`). Action: "Bearbeiten" → POST creates an override.
+ *  - `isOverride: true` → tenant row that overrides a system default. Action: "Zurücksetzen" → reset.
+ *  - else               → custom tenant slot. Action: "Löschen" → real delete (no restore).
+ */
+interface LtAiEffectiveSlot {
+  capability?: string;
+  content: string;
+  description?: string;
+  enabled: boolean;
+  id?: string;
+  /** True when a tenant row overrides a framework default. */
+  isOverride: boolean;
+  /** True for built-in framework defaults (no DB row). */
+  isSystem: boolean;
+  key: string;
+  locale?: string;
+  order: number;
+  scope?: string;
+  /** System-default key this row overrides (only on overrides). */
+  systemKey?: string;
+  tenantId?: string;
+}
+/**
+ * Public metadata of a registered placeholder — returned by the placeholders
+ * endpoint. Used by the slot / prompt editors to render a "what can I insert"
+ * hint sidebar dynamically (no hard-coded list in the frontend).
+ */
+interface LtAiPlaceholder {
+  /** One-sentence description shown in the helper sidebar. */
+  description: string;
+  /** Optional example value (tooltip). */
+  example?: string;
+  /** Token name without curly braces (e.g. `'roles'` matches `{{roles}}`). */
+  name: string;
+}
+/**
+ * A learned prompt hint from the governed self-improvement loop. Only `approved`
+ * + enabled hints reach the prompt; hints only ever ADD guidance and can never
+ * relax the backend-enforced security core.
+ */
+interface LtAiPromptHint {
+  /** Guidance text added to the prompt when approved. */
+  content: string;
+  createdAt?: string;
+  /** Whether the hint is active. */
+  enabled?: boolean;
+  id: string;
+  /** Number of times the failure pattern was observed. */
+  occurrences?: number;
+  /** Scope the hint applies to (e.g. a tool name); empty = global. */
+  scope?: string;
+  /** Governance status: 'suggested', 'approved' or 'rejected'. */
+  status?: string;
+  /** Failure-pattern identifier that produced the hint. */
+  trigger?: string;
+  updatedAt?: string;
+}
+/** Input to create/update a learned prompt hint (typically approve/reject or edit). */
+interface LtAiPromptHintInput {
+  content?: string;
+  enabled?: boolean;
+  occurrences?: number;
+  scope?: string;
+  status?: string;
+  trigger?: string;
+}
+/**
+ * A user-facing prompt ("Vorlage") — a short, named piece of text the user
+ * can insert into the chat input with one click. Different from
+ * {@link LtAiSlot}, which is the admin-only system-prompt building block.
+ *
+ * Visibility scopes:
+ *  - `user`   — only the owner sees it ("private", default).
+ *  - `tenant` — all members of the owner's tenant see it ("public").
+ */
+interface LtAiPrompt {
+  /** The prompt text inserted into the chat input (may contain placeholders). */
+  content: string;
+  createdAt?: string;
+  /** Optional description. */
+  description?: string;
+  /** Whether the prompt is active (disabled prompts are hidden). */
+  enabled?: boolean;
+  /** Optional icon hint (lucide name or single emoji). */
+  icon?: string;
+  id: string;
+  /** Display label shown in the picker. */
+  name: string;
+  /** Owner user id (set automatically by the server). */
+  ownerId?: string;
+  /** Sort order in the picker (ascending). */
+  order?: number;
+  /** Visibility scope (`'user'` | `'tenant'` | `'global'`). */
+  scope: string;
+  /** Tenant id when `scope === 'tenant'` (set automatically by the server). */
+  tenantId?: string;
+  updatedAt?: string;
+}
+/**
+ * Input to create/update a {@link LtAiPrompt} (user-facing "Vorlage").
+ *
+ * Distinct from {@link LtAiPromptRunInput} (the payload for `LtAiService.prompt()`).
+ * Used by `LtAiPromptsService.create()` / `.update()`.
+ */
+interface LtAiPromptInput {
+  content?: string;
+  description?: string;
+  enabled?: boolean;
+  icon?: string;
+  name?: string;
+  order?: number;
+  scope?: string;
+}
+interface LtAiState {
+  error: Signal<null | string>;
+  loading: Signal<boolean>;
+  prompt: (input: LtAiPromptRunInput) => Promise<LtAiResponse>;
+  promptStream: (input: LtAiPromptRunInput, handlers?: LtAiStreamHandlers, options?: {
+    signal?: AbortSignal;
+  }) => Promise<LtAiResponse | undefined>;
+  streaming: Signal<boolean>;
+}
+interface LtAiChatOptions {
+  /** Fixed connection id (or a ref) to use for every turn. */
+  connectionId?: Signal<string | undefined> | string;
+  /**
+   * Existing conversation id to continue (or a signal). When the signal changes, the chat continues that conversation;
+   * the server's answer updates the chat's own `conversationId` either way.
+   */
+  conversationId?: Signal<string | undefined> | string;
+  /**
+   * Cap the local `messages` array. When the cap is exceeded after a new push,
+   * the oldest entries are removed. Use this for long-running chats to prevent
+   * unbounded memory growth. Server-side conversation history is unaffected.
+   */
+  maxMessages?: number;
+  /** Producer for per-turn client metadata (e.g. current URL). */
+  metadata?: () => Record<string, unknown>;
+  /** Execution mode for every turn (or a signal, read per turn). */
+  mode?: LtAiMode | Signal<LtAiMode | undefined>;
+  /** Whether to stream responses (default true). */
+  stream?: boolean;
+}
+interface LtAiChatState {
+  budget: Signal<LtAiBudgetSummary | null>;
+  clear: () => void;
+  confirm: () => Promise<void>;
+  /** Context-window utilization of the latest assistant turn (used/total tokens). */
+  contextWindow: Signal<{
+    total: number;
+    used: number;
+  } | null>;
+  conversationId: Signal<string | undefined>;
+  error: Signal<null | string>;
+  messages: Signal<LtAiMessage[]>;
+  requiresConfirmation: Signal<boolean>;
+  send: (content: string) => Promise<void>;
+  stop: () => void;
+  streaming: Signal<boolean>;
+}
+interface LtAiConnectionsState {
+  connections: Signal<LtAiAvailableConnection[]>;
+  error: Signal<null | string>;
+  loading: Signal<boolean>;
+  load: () => Promise<void>;
+  locked: Signal<boolean>;
+  select: (connectionId: string) => Promise<void>;
+  selected: Signal<LtAiAvailableConnection | undefined>;
+}
+interface LtAiStatusState {
+  enabled: Signal<boolean>;
+  error: Signal<null | string>;
+  /** Reads the status once per app start; `force` asks again. Never throws. */
+  load: (options?: {
+    force?: boolean;
+  }) => Promise<void>;
+  loaded: Signal<boolean>;
+  mcp: Signal<boolean>;
+}
+interface LtAiSettingsState {
+  /** True when the server fixed the MCP confirmation: show the switch disabled. */
+  enforced: Signal<boolean>;
+  error: Signal<null | string>;
+  load: () => Promise<void>;
+  loading: Signal<boolean>;
+  settings: Signal<LtAiSettings | null>;
+  /** Stores the user's choice and adopts the answer; throws (and sets `error`) when refused. */
+  update: (input: LtAiSettingsInput) => Promise<void>;
+}
+interface LtAiUsageState {
+  error: Signal<null | string>;
+  loading: Signal<boolean>;
+  load: () => Promise<void>;
+  usage: Signal<LtAiUsageInfo | null>;
+}
+/**
+ * User-facing prompt service. Lets any signed-in user manage their own
+ * prompts ("Vorlagen") and use the visible ones (own private + tenant public)
+ * in a chat.
+ */
+interface LtAiPromptsState {
+  create: (input: LtAiPromptInput) => Promise<LtAiPrompt>;
+  error: Signal<null | string>;
+  load: () => Promise<void>;
+  loading: Signal<boolean>;
+  prompts: Signal<LtAiPrompt[]>;
+  remove: (id: string) => Promise<LtAiPrompt>;
+  update: (id: string, input: LtAiPromptInput) => Promise<LtAiPrompt>;
+}
+/**
+ * Admin AI service surface — headless on purpose: every method returns the
+ * raw backend response. No shared `loading` / `error` refs because admin
+ * screens typically need per-row spinners and per-action toasts that a single
+ * shared ref cannot model. Wire each call to your UI layer's loading/error
+ * scheme.
+ *
+ * All endpoints are server-side `@Restricted(ADMIN)`; the service itself
+ * does not enforce role. Render admin UI behind a frontend route guard for UX,
+ * but trust the backend for authorization.
+ */
+interface LtAiAdminState {
+  /** Create a per-user/per-tenant budget limit override (POST /ai/budget-limits). */
+  createBudgetLimit: (input: LtAiBudgetLimit) => Promise<LtAiBudgetLimit>;
+  /** Create a connection. `input.apiKey` is write-only; the response never echoes it. */
+  createConnection: (input: LtAiConnectionInput) => Promise<LtAiConnection>;
+  /** Create a learned prompt hint (typically used to manually approve/reject). */
+  createPromptHint: (input: LtAiPromptHintInput) => Promise<LtAiPromptHint>;
+  /** Create a tenant-scoped system-prompt slot row (overrides framework default for `key`). */
+  createSlot: (input: LtAiSlotInput) => Promise<LtAiSlot>;
+  deleteBudgetLimit: (id: string) => Promise<LtAiBudgetLimit>;
+  deleteConnection: (id: string) => Promise<LtAiConnection>;
+  /** Delete a connection preference by its preference id (NOT the user/tenant id). */
+  deletePreference: (id: string) => Promise<LtAiConnectionPreference>;
+  deletePromptHint: (id: string) => Promise<LtAiPromptHint>;
+  deleteSlot: (id: string) => Promise<LtAiSlot>;
+  /**
+   * Re-detect a connection's `capabilities` / `supportsNativeTools` / `supportsVision`
+   * by probing the provider. Mutates the persisted connection row.
+   */
+  detectCapabilities: (id: string) => Promise<LtAiConnection>;
+  /** Returns the connection WITHOUT the `apiKey` (only `hasApiKey: boolean`). */
+  getConnection: (id: string) => Promise<LtAiConnection>;
+  listBudgetLimits: () => Promise<LtAiBudgetLimit[]>;
+  listConnections: () => Promise<LtAiConnection[]>;
+  /** Effective slots view — framework defaults overlaid by tenant overrides + tenant customs. */
+  listEffectiveSlots: () => Promise<LtAiEffectiveSlot[]>;
+  /** Recent AI interactions (audit log, ADMIN-only). */
+  listInteractions: () => Promise<LtAiInteraction[]>;
+  listPreferences: () => Promise<LtAiConnectionPreference[]>;
+  listPromptHints: () => Promise<LtAiPromptHint[]>;
+  /** List ONLY tenant overrides + customs (not the framework defaults — use `listEffectiveSlots` for that). */
+  listSlots: () => Promise<LtAiSlot[]>;
+  /** Reset a tenant override → framework default applies again. */
+  resetSlot: (id: string) => Promise<boolean>;
+  /**
+   * Upsert a connection preference for the given `refId` (user or tenant) +
+   * `scope`. Replaces the existing row for that scope if present.
+   */
+  setPreference: (input: LtAiConnectionPreference) => Promise<LtAiConnectionPreference>;
+  updateBudgetLimit: (id: string, input: LtAiBudgetLimit) => Promise<LtAiBudgetLimit>;
+  /**
+   * Update a connection. `input.apiKey`: pass the new value to set, an empty
+   * string `''` to clear, omit to leave the stored key unchanged.
+   */
+  updateConnection: (id: string, input: LtAiConnectionInput) => Promise<LtAiConnection>;
+  updatePromptHint: (id: string, input: LtAiPromptHintInput) => Promise<LtAiPromptHint>;
+  updateSlot: (id: string, input: LtAiSlotInput) => Promise<LtAiSlot>;
+}
+/**
+ * Placeholder list service. Loads the runtime placeholder registry from
+ * the backend (`GET /ai/placeholders`) so slot / prompt editors can render
+ * a dynamic helper sidebar without hard-coding any names in the frontend.
+ */
+interface LtAiPlaceholdersState {
+  error: Signal<null | string>;
+  load: () => Promise<void>;
+  loading: Signal<boolean>;
+  placeholders: Signal<LtAiPlaceholder[]>;
+}
+/** A chat session created by {@link injectLtAiChat}. */
+type LtAiChat = LtAiChatState;
+/**
+ * Create a chat session (counterpart of `useLtAiChat()`), bound to the current injection context: a running stream is
+ * stopped on destroy. Streams by default; `send` is ignored while a turn runs; `confirm()` re-sends the last prompt with
+ * `confirm: true`; abort is not an error; `maxMessages` trims the oldest messages.
+ *
+ * Every chat has its own state (messages, conversation, budget, streaming); it does not share `LtAiService`'s signals.
+ * A stream `error` event marks the assistant turn as failed and sets `error`, like a failed request.
+ *
+ * @example
+ * protected readonly chat = injectLtAiChat({ connectionId: this.connectionId, metadata: () => ({ url: location.href }) });
+ */
+export declare function injectLtAiChat(options?: LtAiChatOptions): LtAiChat;
+/**
+ * Admin AI endpoints, headless on purpose: every method returns the raw response, no shared loading/error state.
+ * ADMIN is enforced server-side (`@Restricted(ADMIN)`). Ids are `encodeURIComponent`-ed.
+ */
+export declare class LtAiAdminService implements LtAiAdminState {
+  private readonly http;
+  listConnections: () => Promise<LtAiConnection[]>;
+  createConnection: (input: LtAiConnectionInput) => Promise<LtAiConnection>;
+  getConnection: (id: string) => Promise<LtAiConnection>;
+  updateConnection: (id: string, input: LtAiConnectionInput) => Promise<LtAiConnection>;
+  deleteConnection: (id: string) => Promise<LtAiConnection>;
+  detectCapabilities: (id: string) => Promise<LtAiConnection>;
+  listPreferences: () => Promise<LtAiConnectionPreference[]>;
+  setPreference: (input: LtAiConnectionPreference) => Promise<LtAiConnectionPreference>;
+  deletePreference: (id: string) => Promise<LtAiConnectionPreference>;
+  listBudgetLimits: () => Promise<LtAiBudgetLimit[]>;
+  createBudgetLimit: (input: LtAiBudgetLimit) => Promise<LtAiBudgetLimit>;
+  updateBudgetLimit: (id: string, input: LtAiBudgetLimit) => Promise<LtAiBudgetLimit>;
+  deleteBudgetLimit: (id: string) => Promise<LtAiBudgetLimit>;
+  listSlots: () => Promise<LtAiSlot[]>;
+  listEffectiveSlots: () => Promise<LtAiEffectiveSlot[]>;
+  createSlot: (input: LtAiSlotInput) => Promise<LtAiSlot>;
+  updateSlot: (id: string, input: LtAiSlotInput) => Promise<LtAiSlot>;
+  deleteSlot: (id: string) => Promise<LtAiSlot>;
+  resetSlot: (id: string) => Promise<boolean>;
+  listPromptHints: () => Promise<LtAiPromptHint[]>;
+  createPromptHint: (input: LtAiPromptHintInput) => Promise<LtAiPromptHint>;
+  updatePromptHint: (id: string, input: LtAiPromptHintInput) => Promise<LtAiPromptHint>;
+  deletePromptHint: (id: string) => Promise<LtAiPromptHint>;
+  listInteractions: () => Promise<LtAiInteraction[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiAdminService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Connections the user may pick (`GET /ai/connections/available`, `POST /ai/connections/select`), the counterpart
+ * of `useLtAiConnections()`. `selected` is the connection flagged `selected`; `locked` is true when a mandatory layer
+ * applies (any connection flagged `locked`), then the picker should be read-only.
+ */
+export declare class LtAiConnectionsService implements LtAiConnectionsState {
+  private readonly http;
+  private readonly calls;
+  private readonly list;
+  readonly connections: import("@angular/core").Signal<LtAiAvailableConnection[]>;
+  readonly error: import("@angular/core").Signal<string | null>;
+  readonly loading: import("@angular/core").Signal<boolean>;
+  readonly locked: import("@angular/core").Signal<boolean>;
+  readonly selected: import("@angular/core").Signal<LtAiAvailableConnection | undefined>;
+  /** Load the available connections; a failure sets `error` and does not throw. */
+  load(): Promise<void>;
+  /** Make `connectionId` the user's default; adopts the list the server answers with. Throws (and sets `error`) when refused. */
+  select(connectionId: string): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiConnectionsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Maximum length of one SSE line (1 MiB); longer lines abort the stream. */
+export declare const LT_AI_SSE_MAX_LINE: number;
+/** HTTP helpers of the AI services (counterpart of `buildLtAiUrl` / `ltAiRequest`). All calls use the auth-aware `LT_FETCH`. */
+export declare class LtAiHttpService {
+  private readonly api;
+  private readonly fetch;
+  private readonly options;
+  /** AI base path (`/ai`). */
+  basePath(): string;
+  /** `<api><basePath><path>`. */
+  buildUrl(path: string): string;
+  /** JSON request (`Accept: application/json`); throws {@link ltAiResponseError} on non-2xx; 204 → `undefined`. */
+  request<T>(method: 'DELETE' | 'GET' | 'POST' | 'PUT', path: string, body?: unknown, options?: {
+    signal?: AbortSignal;
+  }): Promise<T>;
+  /** Raw request for streaming (`POST /ai/stream`). */
+  stream(path: string, body: unknown, options?: {
+    signal?: AbortSignal;
+  }): Promise<Response>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiHttpService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Build an `Error & { status }` from an error response (`message`/`error`, arrays joined, capped at 1 KiB). */
+export declare function ltAiResponseError(response: Response): Promise<Error & {
+  status: number;
+}>;
+/**
+ * Parse an SSE response body (`data: {json}` lines) and call `onEvent` per event. Handles chunks split mid-line,
+ * ignores non-`data:` lines, `[DONE]` and malformed JSON, throws on lines over 1 MiB; aborting cancels the reader.
+ *
+ * `options.signal` stops parsing without cancelling the underlying fetch (component-destroy races): the reader is
+ * cancelled, also while it waits for the next chunk, and the function resolves without delivering further events.
+ * An error thrown by `onEvent` propagates (and cancels the reader); only unparsable payloads are skipped.
+ */
+export declare function parseLtAiSseStream(response: Response, onEvent: (event: LtAiStreamEvent) => void, options?: {
+  signal?: AbortSignal;
+}): Promise<void>;
+/** Options of `provideLtAi()`; runtime override `NG_PUBLIC_LT_AI_BASE_PATH`. */
+interface LtAiOptions {
+  /** REST base of the nest-server AI controller (default `/ai`). */
+  basePath?: string;
+}
+/** Resolved AI options. */
+export declare const LT_AI_OPTIONS: InjectionToken<Required<LtAiOptions>>;
+/** AI providers (base path). The AI services work without it with the defaults. */
+export declare function provideLtAi(options?: LtAiOptions): EnvironmentProviders;
+/**
+ * Runtime placeholder registry for prompts (`GET /ai/placeholders`), the counterpart of `useLtAiPlaceholders()`, so
+ * slot/prompt editors can list the supported `{{placeholders}}` without hard-coding them.
+ */
+export declare class LtAiPlaceholdersService implements LtAiPlaceholdersState {
+  private readonly http;
+  private readonly calls;
+  private readonly list;
+  readonly error: import("@angular/core").Signal<string | null>;
+  readonly loading: import("@angular/core").Signal<boolean>;
+  readonly placeholders: import("@angular/core").Signal<LtAiPlaceholder[]>;
+  /** Load the registry; a failure sets `error`, empties the list and does not throw. */
+  load(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiPlaceholdersService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Saved prompts ("Vorlagen") of the user and the tenant (`GET/POST /ai/prompts`, `PUT/DELETE /ai/prompts/:id`), the
+ * counterpart of `useLtAiPrompts()`. `load()` returns what the user may see (own + tenant), filtered by the server.
+ * The list reloads after each mutation; ids are `encodeURIComponent`-ed.
+ */
+export declare class LtAiPromptsService implements LtAiPromptsState {
+  private readonly http;
+  private readonly calls;
+  private readonly list;
+  private loadSequence;
+  readonly error: import("@angular/core").Signal<string | null>;
+  readonly loading: import("@angular/core").Signal<boolean>;
+  readonly prompts: import("@angular/core").Signal<LtAiPrompt[]>;
+  /** Load the visible prompts; a failure sets `error`, empties the list and does not throw. Only the latest load is applied. */
+  load(): Promise<void>;
+  /** Create a prompt and reload the list; throws (and sets `error`) when refused. */
+  create(input: LtAiPromptInput): Promise<LtAiPrompt>;
+  /** Update a prompt and reload the list; throws (and sets `error`) when refused. */
+  update(id: string, input: LtAiPromptInput): Promise<LtAiPrompt>;
+  /** Delete a prompt and reload the list; throws (and sets `error`) when refused. */
+  remove(id: string): Promise<LtAiPrompt>;
+  private mutate;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiPromptsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Prompt runs (`POST /ai/prompt`) and the SSE stream (`POST /ai/stream`, events token/action/error/final), the
+ * counterpart of `useLtAi()`. Headless: pair it with an own UI or use {@link injectLtAiChat}.
+ *
+ * Root service: `loading` and `streaming` stay `true` while any call of the kind runs, `error` holds the latest
+ * failure (an abort is not one).
+ */
+export declare class LtAiService implements LtAiState {
+  private readonly http;
+  private readonly calls;
+  private readonly streams;
+  /** Message of the latest failed run or stream `error` event. */
+  readonly error: import("@angular/core").Signal<string | null>;
+  /** `true` while a `prompt()` runs. */
+  readonly loading: import("@angular/core").Signal<boolean>;
+  /** `true` while a `promptStream()` runs. */
+  readonly streaming: import("@angular/core").Signal<boolean>;
+  /** Run a prompt and return the full structured response; rejects (and sets `error`) on a non-2xx answer. */
+  prompt(input: LtAiPromptRunInput): Promise<LtAiResponse>;
+  /**
+   * Run a prompt and stream the answer; resolves with the final response, or `undefined` when the backend closes the
+   * stream without a `final` event. A stream `error` event sets `error` and calls `handlers.onError` without
+   * rejecting. Aborting through `options.signal` rejects with an `AbortError` and leaves `error` untouched.
+   *
+   * Meant for the browser: during SSR the render waits until the stream ends.
+   */
+  promptStream(input: LtAiPromptRunInput, handlers?: LtAiStreamHandlers, options?: {
+    signal?: AbortSignal;
+  }): Promise<LtAiResponse | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * The user's own AI settings (`GET/PUT /ai/settings`, nest-server >= 12.3.0), the counterpart of `useLtAiSettings()`.
+ *
+ * The answer is always the setting as it takes effect and is adopted as is. When the server fixes it
+ * (`ai.mcp.confirmation.enforced`), `enforced` is true, the switch should be shown disabled, and `update()` is refused
+ * with 403 `#LTNS_0609` (the previous value stays).
+ */
+export declare class LtAiSettingsService implements LtAiSettingsState {
+  private readonly http;
+  private readonly calls;
+  private readonly current;
+  readonly enforced: import("@angular/core").Signal<boolean>;
+  readonly error: import("@angular/core").Signal<string | null>;
+  readonly loading: import("@angular/core").Signal<boolean>;
+  readonly settings: import("@angular/core").Signal<LtAiSettings | null>;
+  /** Load the settings; a failure sets `error` and does not throw. */
+  load(): Promise<void>;
+  /** Store the user's choice and adopt the server's answer; throws (and sets `error`) when refused. */
+  update(input: LtAiSettingsInput): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiSettingsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** `TransferState` key under which the server hands the AI status to the browser. */
+export declare const LT_AI_STATUS_STATE_KEY: import("@angular/core").StateKey<LtAiStatus>;
+/** Upper bound of the status request, so a hanging API cannot stall every server render. */
+export declare const LT_AI_STATUS_TIMEOUT_MS = 5000;
+/**
+ * Whether the API's AI module is on (`GET /ai/status`, no credentials, 5 s timeout), the counterpart of
+ * `useLtAiStatus()`. nest-server answers 200 `{ mcp }` while the module is on and 404 while it is off.
+ *
+ * One request per app: concurrent `load()` calls share it, a loaded status is not asked again unless `force` is set.
+ * On the server the render waits for the answer and the status travels to the browser via `TransferState`, so the
+ * browser adopts it without a second request. Sent without credentials: the endpoint is public and the auth-aware
+ * fetch would start its 401 handling for nothing.
+ *
+ * Fails closed: anything but a well-formed 200 leaves `enabled` false. A 404 is an answer ("AI is off") and sets no
+ * `error`; a network error, a timeout, any other status or a malformed body sets a fixed `error` text, never the raw
+ * error message (on the server that may carry the private API URL incl. credentials and ends up in the HTML).
+ */
+export declare class LtAiStatusService implements LtAiStatusState {
+  private readonly http;
+  private readonly transferState;
+  private readonly pendingTasks;
+  private readonly isServer;
+  private readonly state;
+  private inflight;
+  readonly enabled: import("@angular/core").Signal<boolean>;
+  readonly error: import("@angular/core").Signal<string | null>;
+  readonly loaded: import("@angular/core").Signal<boolean>;
+  readonly mcp: import("@angular/core").Signal<boolean>;
+  /** Read the status once per app start; `force` asks again. Never throws. */
+  load(options?: {
+    force?: boolean;
+  }): Promise<void>;
+  private fetchStatus;
+  private readTransferred;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiStatusService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Token/prompt usage and budget of user and tenant (`GET /ai/usage`), the counterpart of `useLtAiUsage()`. The compact
+ * per-response budget is on every prompt response (see `injectLtAiChat().budget`); this loads the full breakdown.
+ */
+export declare class LtAiUsageService implements LtAiUsageState {
+  private readonly http;
+  private readonly calls;
+  private readonly current;
+  readonly error: import("@angular/core").Signal<string | null>;
+  readonly loading: import("@angular/core").Signal<boolean>;
+  readonly usage: import("@angular/core").Signal<LtAiUsageInfo | null>;
+  /** Load the usage; a failure sets `error` and does not throw. */
+  load(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LtAiUsageService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type { LtAiAction, LtAiAdminState, LtAiAvailableConnection, LtAiBudgetLimit, LtAiBudgetSummary, LtAiChat, LtAiChatOptions, LtAiChatState, LtAiConnection, LtAiConnectionInput, LtAiConnectionPreference, LtAiConnectionsState, LtAiEffectiveSlot, LtAiInteraction, LtAiMessage, LtAiMode, LtAiOptions, LtAiPlaceholder, LtAiPlaceholdersState, LtAiPrompt, LtAiPromptHint, LtAiPromptHintInput, LtAiPromptInput, LtAiPromptRunInput, LtAiPromptsState, LtAiResponse, LtAiSettings, LtAiSettingsInput, LtAiSettingsState, LtAiSlot, LtAiSlotInput, LtAiState, LtAiStatus, LtAiStatusState, LtAiStreamEvent, LtAiStreamHandlers, LtAiUsage, LtAiUsageInfo, LtAiUsageScope, LtAiUsageState };