@meshmakers/octo-ai-console 3.3.1190

package/types/meshmakers-octo-ai-console.d.ts

@@ -0,0 +1,575 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, EnvironmentProviders } from '@angular/core';
+import { Observable, Subject, ReplaySubject } from 'rxjs';
+
+/**
+ * Status names emitted by the adapter's session lifecycle (RtSessionStatusEnum in C#).
+ * Wire format is the enum name so the UI does not need to know the underlying integer
+ * mapping — this union mirrors the values currently emitted on the wire.
+ */
+type AiSessionStatus = 'Queued' | 'Running' | 'Paused' | 'Completed' | 'Failed' | 'Cancelled' | 'QuotaBlocked' | 'RateLimited';
+/**
+ * Job kinds classify the prompt-template family + tool-policy track. Mirrors
+ * RtJobKindEnum in System.Ai-3. Phase-1 default is `DataModel`.
+ */
+type AiJobKind = 'DataModel' | 'Application' | 'Deployment' | 'Investigation';
+/**
+ * Wire shape returned from every adapter session endpoint. Mirrors
+ * `SessionResponse` on the C# side (src/AiServices/TenantApi/v1/Models).
+ */
+interface AiSessionDto {
+    readonly sessionRtId: string;
+    readonly jobRtId: string;
+    readonly goalSummary: string;
+    readonly status: AiSessionStatus;
+    readonly startedAt: string;
+    readonly completedAt?: string | null;
+    readonly tokensConsumed: number;
+    readonly ownerUserId: string;
+    /**
+     * Per-session preview URL (#4136) — present on sessions whose worker pod
+     * has the preview-deploy sidecar enabled AND the agent's
+     * `npm run build:prod` has emitted a dist under the convention path
+     * (`/workspaces/preview/{sessionRtId}/dist`). The server composes the URL
+     * via `AiWorkspaceOptions.PreviewUrlPattern`; absent / empty when the
+     * feature is off or no build is ready yet.
+     */
+    readonly previewUrl?: string | null;
+}
+/**
+ * Quota gate decision snapshot as observed at the moment a session was created (or
+ * polled). Mirrors `QuotaSnapshot` server-side. `decision` is the enum name; useful
+ * values are `Admit` / `Queue` / `BlockMonthlyCap` etc.
+ */
+interface AiQuotaSnapshotDto {
+    readonly decision: string;
+    readonly concurrentJobsCap: number;
+    readonly maxSessionsQueuedCap: number;
+    readonly currentActive: number;
+    readonly currentQueued: number;
+    readonly queuePosition: number;
+}
+/**
+ * Body for `POST /{tenantId}/v1/sessions`. The owning user is taken from the JWT
+ * subject claim — clients never send a user id on the request.
+ */
+interface CreateSessionRequestDto {
+    readonly goal: string;
+    readonly jobKind?: AiJobKind;
+}
+/**
+ * Response for `POST /{tenantId}/v1/sessions`. Carries the freshly persisted
+ * session plus the quota decision so the UI can render a "Running" pill or a
+ * "Queued (3 / 10)" pill without a second round-trip.
+ */
+interface CreateSessionResponseDto {
+    readonly session: AiSessionDto;
+    readonly quota: AiQuotaSnapshotDto;
+}
+
+/**
+ * Event kinds emitted as stream-json lines by the Claude Code worker (and synthetic
+ * lines from the orchestrator). Mirrors `RtAiSessionEventKindEnum` in System.Ai-3.
+ */
+type AiSessionEventKind = 'Message' | 'ToolCall' | 'ToolResult' | 'StatusChange' | 'Hook' | 'Error';
+/**
+ * Payload pushed by the adapter's SignalR `OnSessionEventAsync` callback. Mirrors
+ * `SessionEventEnvelope` on the C# side.
+ */
+interface AiSessionEventDto {
+    readonly sessionId: string;
+    readonly kind: AiSessionEventKind;
+    readonly sequence: number;
+    readonly payload: string;
+    readonly actorRef: string;
+    readonly at: string;
+}
+/**
+ * Payload pushed by `OnSessionStatusChangedAsync`. Mirrors
+ * `SessionStatusChangedEnvelope` on the C# side.
+ */
+interface AiSessionStatusChangedDto {
+    readonly sessionId: string;
+    readonly newStatus: AiSessionStatus;
+    readonly reason?: string | null;
+    readonly at: string;
+}
+/**
+ * Decoded tool-call lifted from an `AiSessionEvent` payload. Owned by the UI
+ * because the adapter wire format is a stream-json string and the components
+ * render structured fields.
+ */
+interface AiToolCallDto {
+    readonly sessionId: string;
+    readonly callId: string;
+    readonly toolName: string;
+    readonly arguments: unknown;
+    readonly result?: unknown;
+    readonly status: 'Pending' | 'Approved' | 'Rejected' | 'Succeeded' | 'Failed';
+    readonly startedAt: string;
+    readonly completedAt?: string | null;
+    readonly durationMs?: number | null;
+}
+
+/**
+ * Approval outcome — mirrors the `ApprovalOutcome` enum the adapter writes back
+ * after the user decides. The hub serialises the enum name on the wire.
+ */
+type AiApprovalOutcome = 'Approved' | 'Rejected';
+/**
+ * Why the approval gate fired. Mirrors `RtApprovalReasonEnum` in System.Ai-3.
+ * The strings match the C# enum value names verbatim — the adapter serialises
+ * the enum name, not its integer value, on the wire.
+ */
+type AiApprovalReason = 'HighRiskTool' | 'PerToolOverride' | 'PolicyDenied' | 'TenantOverride' | 'TimeoutResume';
+/**
+ * Payload pushed by `OnApprovalRequestedAsync`. Mirrors
+ * `ApprovalRequestedEnvelope` on the C# side.
+ */
+interface AiApprovalRequestedDto {
+    readonly requestId: string;
+    readonly sessionId: string;
+    readonly toolName: string;
+    readonly payload: string;
+    readonly reason: AiApprovalReason | string;
+    readonly at: string;
+}
+/**
+ * Payload pushed by `OnApprovalDecidedAsync`. Mirrors `ApprovalDecidedEnvelope`
+ * on the C# side. Fanned to every connection so a UI in a sibling browser tab
+ * dismisses its modal too.
+ */
+interface AiApprovalDecidedDto {
+    readonly requestId: string;
+    readonly outcome: AiApprovalOutcome;
+    readonly comment?: string | null;
+    readonly decidedBy: string;
+    readonly at: string;
+}
+/**
+ * Body for `POST /{tenantId}/v1/sessions/{sessionId}/approvals/{requestId}`.
+ * The UI sends the user's decision; the server fans out
+ * `OnApprovalDecidedAsync` to every connection.
+ */
+interface AiApprovalDecisionDto {
+    readonly outcome: AiApprovalOutcome;
+    readonly comment?: string;
+}
+
+/**
+ * Severity of a quota warning. `Warning` fires at 80% of the daily-tokens cap,
+ * `Critical` fires at 100%. Mirrors the C# discriminator string.
+ */
+type AiQuotaSeverity = 'Warning' | 'Critical';
+/**
+ * Payload pushed by the adapter's `OnQuotaWarningAsync` SignalR callback.
+ * Broadcast to every connection for the tenant when the daily-tokens budget
+ * crosses 80% or 100%. UI renders a banner with the embedded numbers.
+ */
+interface AiQuotaWarningDto {
+    readonly severity: AiQuotaSeverity;
+    readonly thresholdPercent: number;
+    readonly tokensConsumed: number;
+    readonly tokensPerDayCap: number;
+    readonly at: string;
+}
+
+/**
+ * Scopes a one-time credential-registration ticket authorises. Mirrors
+ * `RtTicketScopeEnum` in System.Ai-3 (C# side: enum members
+ * `CredentialRegister`, `DevSshKeyRegister`).
+ */
+type AiCredentialTicketScope = 'CredentialRegister' | 'DevSshKeyRegister';
+/**
+ * Body for `POST /{tenantId}/v1/credentials/tickets`. The admin in Refinery
+ * Studio fills this in to mint a one-time code the developer / operator
+ * redeems from their own machine (#4133). `ttlMinutes` is clamped server-side
+ * to 60 minutes; omitting it defaults to 5 minutes.
+ */
+interface IssueAiCredentialTicketRequestDto {
+    readonly scope: AiCredentialTicketScope;
+    readonly ttlMinutes?: number;
+}
+/**
+ * Wire shape returned from `POST /{tenantId}/v1/credentials/tickets`. The
+ * plaintext `code` is shown to the admin once and discarded after display —
+ * the server stores only the SHA-256 hash, so a future GET cannot re-derive
+ * it (#4133, concept §10).
+ */
+interface IssueAiCredentialTicketResponseDto {
+    readonly rtId: string;
+    readonly code: string;
+    readonly expiresAt: string;
+    readonly scope: AiCredentialTicketScope;
+}
+
+/**
+ * Configuration the host application supplies via {@link provideOctoAiConsole}.
+ * Every field is required so the library never falls back to a hard-coded URL or
+ * tenant id — host apps that wire the library through their own DI container can
+ * surface placeholders explicitly instead.
+ */
+interface AiAdapterOptions {
+    /**
+     * Absolute base URL of the AI Adapter REST API, e.g. `https://ai.acme.cloud`.
+     * Must NOT include a trailing slash. The library appends
+     * `/{tenantId}/v1/sessions...` itself.
+     */
+    readonly baseUrl: string;
+    /**
+     * Tenant whose sessions the host wants to surface. The library renders the
+     * tenant id into every REST URL. Host apps that have multiple tenants must
+     * compose the provider with the tenant id from their routing context.
+     */
+    readonly tenantId: string;
+    /**
+     * SignalR hub path, relative to the base URL, e.g. `/hubs/ai`. Used by
+     * `AiSessionStreamService` to connect when a host calls
+     * `streamSession(sessionId)`.
+     */
+    readonly hubPath: string;
+}
+/**
+ * DI token the services in this library read at construction time.
+ * Provided by {@link provideOctoAiConsole}.
+ */
+declare const AI_ADAPTER_OPTIONS: InjectionToken<AiAdapterOptions>;
+/**
+ * Minimal subset of the `@microsoft/signalr` `HubConnection` surface the library
+ * exercises. The interface stays in the public API so host apps can supply
+ * either the real SignalR connection (Refinery Studio, bastion CLI), a test
+ * mock, or no factory at all — in which case {@link AiSessionStreamService}
+ * falls back to REST-only backfill (Phase-1 stub behaviour). Keeping the type
+ * structural lets the library stay agnostic of the `@microsoft/signalr` major
+ * version line the host has installed.
+ */
+interface AiHubConnectionLike {
+    on(methodName: string, handler: (payload: unknown) => void): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    invoke<T = unknown>(methodName: string, ...args: unknown[]): Promise<T>;
+    onreconnected(handler: (connectionId?: string) => void): void;
+}
+/**
+ * Builds a hub connection against the resolved URL. Return null when streaming
+ * is not wired in this deployment yet — the stream service then quietly skips
+ * the live channel and behaves exactly like the Phase-1 stub.
+ */
+type AiSessionStreamConnectionFactory = (hubUrl: string) => AiHubConnectionLike | null;
+/**
+ * Optional DI token a host application provides to enable the live SignalR
+ * channel on {@link AiSessionStreamService}. When absent, the service degrades
+ * to REST-only backfill.
+ */
+declare const AI_SESSION_STREAM_CONNECTION_FACTORY: InjectionToken<AiSessionStreamConnectionFactory>;
+/**
+ * Composable provider that surfaces the library's adapter configuration to the
+ * Angular DI container. Host applications call this once in `app.config.ts`:
+ *
+ * ```ts
+ * providers: [
+ *   provideOctoAiConsole({
+ *     baseUrl: 'https://ai.acme.cloud',
+ *     tenantId: 'acme',
+ *     hubPath: '/hubs/ai',
+ *   }),
+ * ]
+ * ```
+ */
+declare function provideOctoAiConsole(options: AiAdapterOptions): EnvironmentProviders;
+
+/**
+ * Typed REST client for the AI Adapter's session endpoints. Every method maps
+ * 1:1 to a controller route on the C# side
+ * (`src/AiServices/TenantApi/v1/Controllers/SessionsController.cs`).
+ *
+ * The service does NOT cache responses or hold session state — each call is a
+ * pure pass-through to `HttpClient`. Components that need a derived view (e.g.
+ * a session list with status counts) should compose over the returned
+ * observables themselves; that keeps the client free of UI concerns and lets
+ * host apps mix Apollo / GraphQL state in the same component without dueling
+ * caches.
+ */
+/**
+ * Not `providedIn: 'root'` — `AI_ADAPTER_OPTIONS` is provided per-route in host
+ * apps (the tenant id is read from the route param, which the root injector
+ * doesn't see). A root-provided service would resolve through the root injector
+ * and fail with NG0201 on `AI_ADAPTER_OPTIONS`. Standalone components that
+ * inject this service pick up the route-level provider via the element
+ * injector hierarchy.
+ */
+declare class AiAdapterClientService {
+    private readonly http;
+    private readonly options;
+    /**
+     * `GET /{tenantId}/v1/sessions` — list all sessions for the configured tenant.
+     * Optional `status` filter narrows to one lifecycle state when present.
+     */
+    listSessions(status?: string): Observable<AiSessionDto[]>;
+    /** `GET /{tenantId}/v1/sessions/{sessionId}` — single session by rtId. */
+    getSession(sessionId: string): Observable<AiSessionDto>;
+    /**
+     * `POST /{tenantId}/v1/sessions` — start a new session. Returns the persisted
+     * session plus the quota gate's decision so the caller can render either a
+     * "Running" pill or a "Queued (n)" pill without a second round-trip.
+     */
+    createSession(request: CreateSessionRequestDto): Observable<CreateSessionResponseDto>;
+    /**
+     * `POST /{tenantId}/v1/sessions/{sessionId}/cancel` — request graceful
+     * cancellation; the orchestrator transitions the session to `Cancelled`
+     * once the worker has acknowledged.
+     */
+    cancelSession(sessionId: string): Observable<AiSessionDto>;
+    /**
+     * `GET /{tenantId}/v1/sessions/{sessionId}/events?sinceSequence=N` — replay
+     * persisted events for a session. UI uses this on reconnect to backfill any
+     * events SignalR missed while disconnected (drives the resume-from-sequence
+     * path in {@link AiSessionStreamService}).
+     */
+    listEvents(sessionId: string, sinceSequence?: number): Observable<AiSessionEventDto[]>;
+    /**
+     * `POST /{tenantId}/v1/sessions/{sessionId}/approvals/{requestId}` — submit
+     * the user's decision on a paused approval gate. Server fans
+     * `OnApprovalDecidedAsync` to every connection on the session.
+     */
+    decideApproval(sessionId: string, requestId: string, decision: AiApprovalDecisionDto): Observable<void>;
+    /**
+     * `POST /{tenantId}/v1/credentials/tickets` — mint a one-time credential-
+     * registration ticket (#4133). The admin sees the plaintext code once in
+     * the response; the server stores only the SHA-256 hash. The matching
+     * redemption call (`POST /v1/credentials/tickets/redeem`) is anonymous and
+     * NOT in this client because the redeemer is by design a different person
+     * on a different machine — they use the bastion CLI, not the Studio.
+     */
+    issueCredentialTicket(request: IssueAiCredentialTicketRequestDto): Observable<IssueAiCredentialTicketResponseDto>;
+    private tenantBase;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiAdapterClientService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AiAdapterClientService>;
+}
+
+/**
+ * One open SignalR connection's worth of streams. Sessions get one
+ * `SessionStream` per `streamSession()` call; closing the returned subscription
+ * tears the connection down.
+ */
+interface AiSessionStream {
+    /** Stream-json lines plus orchestrator markers, ordered by `sequence`. */
+    readonly events$: Observable<AiSessionEventDto>;
+    /** Lifecycle transitions for the session. */
+    readonly statusChanges$: Observable<AiSessionStatusChangedDto>;
+    /** Approval gate fired — UI opens the modal. */
+    readonly approvalsRequested$: Observable<AiApprovalRequestedDto>;
+    /** Approval resolved — UI dismisses the modal in every tab. */
+    readonly approvalsDecided$: Observable<AiApprovalDecidedDto>;
+    /** Tenant-wide quota threshold crossed — UI renders a banner. */
+    readonly quotaWarnings$: Observable<AiQuotaWarningDto>;
+    /** Tear down the underlying SignalR connection and complete all observables. */
+    disconnect(): void;
+}
+/**
+ * Internal wrapper around the SignalR connection. The library does not pin a
+ * SignalR version — host applications inject a `HubConnectionBuilder` they
+ * already use, which keeps the library agnostic of the
+ * `@microsoft/signalr` major version line (six and seven have diverged on the
+ * `withAutomaticReconnect()` defaults).
+ *
+ * For now the connection is constructed deferred — `streamSession` builds it on
+ * demand so the host can defer the SignalR JS bundle behind a route lazy-load.
+ * Phase-1 ships a stub backed by `ReplaySubject` so demo apps can drive
+ * components without a live hub; the real connection wiring lives behind a
+ * `connectionFactory` provider the host overrides.
+ */
+/**
+ * Not `providedIn: 'root'` — see <see cref="AiAdapterClientService"/> for the
+ * rationale: `AI_ADAPTER_OPTIONS` is a per-route token, the root injector
+ * cannot resolve it. Element-level injection picks up the route-level provider.
+ */
+declare class AiSessionStreamService {
+    private readonly options;
+    private readonly client;
+    private readonly connectionFactory;
+    /**
+     * Open a streaming session. Returns the per-stream subjects and a
+     * `disconnect()` closer. When the host has provided an
+     * {@link AI_SESSION_STREAM_CONNECTION_FACTORY}, a live SignalR connection is
+     * built against {@link hubUrl} and the five hub callbacks
+     * (`OnSessionEventAsync`, `OnSessionStatusChangedAsync`,
+     * `OnApprovalRequestedAsync`, `OnApprovalDecidedAsync`, `OnQuotaWarningAsync`)
+     * are routed into the matching subject. Without a factory, the service
+     * degrades to REST-only backfill — the original Phase-1 stub contract.
+     *
+     * Tracking the highest sequence we've emitted lets the host reconnect after a
+     * network blip by passing `sinceSequence` to {@link replay} (the SignalR
+     * `onreconnected` hook fires that with the highest seen sequence).
+     */
+    streamSession(sessionId: string): AiSessionStream;
+    /**
+     * Backfill missing events from a known sequence number and push them into
+     * the host's existing stream. Used by a SignalR `onreconnected` hook the
+     * host wires up.
+     */
+    replay(sessionId: string, sinceSequence: number, sink: Subject<AiSessionEventDto> | ReplaySubject<AiSessionEventDto>): void;
+    /**
+     * Tenant-scoped hub URL. Composition matches the AI Adapter's hub map —
+     * `app.MapHub<AiHub>("/{tenantId:tenantId}/aiHub")` — so the host's
+     * `hubPath` is appended after the tenant segment. Host apps that mount the
+     * hub at a different relative path override `hubPath` via
+     * `AI_ADAPTER_OPTIONS`.
+     */
+    get hubUrl(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiSessionStreamService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AiSessionStreamService>;
+}
+
+/**
+ * List view of an AI Adapter tenant's sessions. The host owns data fetching —
+ * the component takes the array as an input signal and emits the rtId on
+ * row click. Keeping it data-source-agnostic lets refinery wire its own
+ * Apollo cache while a bastion CLI could pass static fixtures in a Storybook.
+ */
+declare class AiSessionListComponent {
+    readonly sessions: _angular_core.InputSignal<AiSessionDto[]>;
+    readonly selectedSessionId: _angular_core.InputSignal<string | null>;
+    readonly sessionSelected: _angular_core.OutputEmitterRef<string>;
+    protected readonly orderedSessions: _angular_core.Signal<AiSessionDto[]>;
+    protected onSelect(sessionRtId: string): void;
+    protected age(startedAt: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiSessionListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiSessionListComponent, "mm-ai-session-list", never, { "sessions": { "alias": "sessions"; "required": true; "isSignal": true; }; "selectedSessionId": { "alias": "selectedSessionId"; "required": false; "isSignal": true; }; }, { "sessionSelected": "sessionSelected"; }, never, never, true, never>;
+}
+
+/**
+ * Read-only transcript of a session, derived from the events stream. The
+ * component takes the events as an input signal so the host owns lifetime —
+ * a parent that's already wired `AiSessionStreamService.events$` into a
+ * `toSignal()` just hands the same signal in.
+ *
+ * Markdown rendering is deliberately minimal in Phase 1: the component shows
+ * the raw payload (already JSON or stream-json) in a `<pre>` block. The
+ * concept §10 calls for proper markdown + code-block highlighting; that
+ * upgrade lands behind a `markdown` Input once we've picked a renderer
+ * (markdown-it vs marked) and verified its CSP behaviour.
+ */
+declare class AiChatStreamComponent {
+    readonly events: _angular_core.InputSignal<AiSessionEventDto[]>;
+    /**
+     * Sorted by sequence so out-of-order arrival (the SignalR + REST backfill
+     * union) renders deterministically.
+     */
+    protected readonly orderedEvents: _angular_core.Signal<AiSessionEventDto[]>;
+    protected variant(kind: AiSessionEventDto['kind']): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiChatStreamComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiChatStreamComponent, "mm-ai-chat-stream", never, { "events": { "alias": "events"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Expandable card surface for one tool invocation in a session transcript.
+ * Click the header to toggle arguments + result; the body is rendered as
+ * pretty-printed JSON so the host doesn't need its own json formatter.
+ */
+declare class AiToolCallComponent {
+    readonly call: _angular_core.InputSignal<AiToolCallDto>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    protected readonly statusVariant: _angular_core.Signal<"failed" | "succeeded" | "rejected" | "pending">;
+    protected readonly argumentsJson: _angular_core.Signal<string>;
+    protected readonly resultJson: _angular_core.Signal<string | null>;
+    protected toggleExpanded(): void;
+    private format;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiToolCallComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiToolCallComponent, "mm-ai-tool-call", never, { "call": { "alias": "call"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Approval modal. The host opens it when a `AiApprovalRequestedDto` arrives on
+ * the SignalR stream, fills the `request` input, and listens for the `decide`
+ * output to call `AiAdapterClientService.decideApproval`. The modal itself is
+ * presentation-only: no networking, no global state, no portal magic.
+ *
+ * The host is expected to wrap the modal in its own backdrop / focus-trap so
+ * the library doesn't pull in a positioning dependency (CDK overlay, Kendo
+ * window, ng-bootstrap, …) — each host shop already has one.
+ */
+declare class AiApprovalModalComponent {
+    readonly request: _angular_core.InputSignal<AiApprovalRequestedDto>;
+    readonly decide: _angular_core.OutputEmitterRef<AiApprovalDecisionDto>;
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    protected readonly comment: _angular_core.WritableSignal<string>;
+    protected readonly prettyPayload: _angular_core.Signal<string>;
+    protected approve(): void;
+    protected reject(): void;
+    protected onDismiss(): void;
+    private commentOrUndefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiApprovalModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiApprovalModalComponent, "mm-ai-approval-modal", never, { "request": { "alias": "request"; "required": true; "isSignal": true; }; }, { "decide": "decide"; "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+/**
+ * Two-bar usage indicator (daily + monthly) with threshold colour state.
+ * Inputs are unit-agnostic counts and caps; the component does not parse the
+ * tenant's `AiQuotaLimit` itself — the host is expected to feed numbers the
+ * adapter already aggregated.
+ */
+declare class AiQuotaIndicatorComponent {
+    readonly dailyConsumed: _angular_core.InputSignal<number>;
+    readonly dailyCap: _angular_core.InputSignal<number>;
+    readonly monthlyConsumed: _angular_core.InputSignal<number | null>;
+    readonly monthlyCap: _angular_core.InputSignal<number | null>;
+    protected readonly dailyPercent: _angular_core.Signal<number>;
+    protected readonly monthlyPercent: _angular_core.Signal<number | null>;
+    protected readonly dailyState: _angular_core.Signal<"ok" | "warning" | "critical">;
+    protected readonly monthlyState: _angular_core.Signal<"ok" | "warning" | "critical" | null>;
+    private percent;
+    private toState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiQuotaIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiQuotaIndicatorComponent, "mm-ai-quota-indicator", never, { "dailyConsumed": { "alias": "dailyConsumed"; "required": true; "isSignal": true; }; "dailyCap": { "alias": "dailyCap"; "required": true; "isSignal": true; }; "monthlyConsumed": { "alias": "monthlyConsumed"; "required": false; "isSignal": true; }; "monthlyCap": { "alias": "monthlyCap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Status pill that mirrors the eight values `AiSessionStatus` carries on the
+ * wire. The component is purely visual — it takes a status string in and emits
+ * a CSS class + display label that the host's stylesheet can theme via the
+ * `--mm-ai-status-*` custom properties.
+ */
+declare class AiJobStatusBadgeComponent {
+    readonly status: _angular_core.InputSignal<AiSessionStatus>;
+    protected readonly variant: _angular_core.Signal<"running" | "queued" | "paused" | "completed" | "failed" | "blocked">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiJobStatusBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiJobStatusBadgeComponent, "mm-ai-job-status-badge", never, { "status": { "alias": "status"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Self-service credential-ticket issuer (#4133, concept §10). Admin picks a
+ * scope + TTL, hits **Issue ticket**, copies the displayed code, hands it to
+ * a developer / operator out-of-band. The plaintext code is shown exactly
+ * once — refreshing the panel after issue clears it so a careless screenshot
+ * doesn't leak.
+ *
+ * Theme-neutral by design: visuals use CSS custom properties with neutral
+ * defaults so the host (Refinery Studio LCARS, demo-app, etc.) can override
+ * them via `--mm-ai-ticket-*` variables without touching the component.
+ */
+declare class AiCredentialTicketIssueComponent {
+    private readonly client;
+    protected readonly scope: _angular_core.WritableSignal<AiCredentialTicketScope>;
+    protected readonly ttlMinutes: _angular_core.WritableSignal<number>;
+    protected readonly issuing: _angular_core.WritableSignal<boolean>;
+    protected readonly issued: _angular_core.WritableSignal<IssueAiCredentialTicketResponseDto | null>;
+    protected readonly error: _angular_core.WritableSignal<string | null>;
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
+    /** Available scope choices — kept in sync with `AiCredentialTicketScope`. */
+    protected readonly scopes: readonly {
+        value: AiCredentialTicketScope;
+        label: string;
+        hint: string;
+    }[];
+    protected onIssue(): void;
+    protected onCopy(): void;
+    protected onClear(): void;
+    private normalizedTtl;
+    private formatError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiCredentialTicketIssueComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiCredentialTicketIssueComponent, "mm-ai-credential-ticket-issue", never, {}, {}, never, never, true, never>;
+}
+
+export { AI_ADAPTER_OPTIONS, AI_SESSION_STREAM_CONNECTION_FACTORY, AiAdapterClientService, AiApprovalModalComponent, AiChatStreamComponent, AiCredentialTicketIssueComponent, AiJobStatusBadgeComponent, AiQuotaIndicatorComponent, AiSessionListComponent, AiSessionStreamService, AiToolCallComponent, provideOctoAiConsole };
+export type { AiAdapterOptions, AiApprovalDecidedDto, AiApprovalDecisionDto, AiApprovalOutcome, AiApprovalReason, AiApprovalRequestedDto, AiCredentialTicketScope, AiHubConnectionLike, AiJobKind, AiQuotaSeverity, AiQuotaSnapshotDto, AiQuotaWarningDto, AiSessionDto, AiSessionEventDto, AiSessionEventKind, AiSessionStatus, AiSessionStatusChangedDto, AiSessionStream, AiSessionStreamConnectionFactory, AiToolCallDto, CreateSessionRequestDto, CreateSessionResponseDto, IssueAiCredentialTicketRequestDto, IssueAiCredentialTicketResponseDto };