@umbraco-ai/core 1.0.0

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@umbraco-ai/core",
+  "version": "1.0.0",
+  "type": "module",
+  "types": "./types/umbraco-ai-public-types.d.ts",
+  "files": [
+    "types/umbraco-ai-public-types.d.ts",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "chart.js": "^4.5.1",
+    "diff": "^8.0.3",
+    "@umbraco-cms/backoffice": "^17.1.0"
+  }
+}

package/types/umbraco-ai-public-types.d.ts

@@ -0,0 +1,1130 @@
+import { CSSResult } from 'lit';
+import { HTMLElementConstructor } from '@umbraco-cms/backoffice/extension-api';
+import type { ManifestBase } from '@umbraco-cms/backoffice/extension-api';
+import { Observable } from '@umbraco-cms/backoffice/external/rxjs';
+import { Observable as Observable_2 } from 'rxjs';
+import { TemplateResult } from 'lit-html';
+import type { TemplateResult as TemplateResult_2 } from '@umbraco-cms/backoffice/external/lit';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { UmbDetailRepository } from '@umbraco-cms/backoffice/repository';
+import { UmbEntityActionBase } from '@umbraco-cms/backoffice/entity-action';
+import { UmbEntityActionEvent } from '@umbraco-cms/backoffice/entity-action';
+import { UmbEntityBulkActionBase } from '@umbraco-cms/backoffice/entity-bulk-action';
+import { UmbFormControlMixinElement } from '@umbraco-cms/backoffice/validation';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { UmbModalBaseElement } from '@umbraco-cms/backoffice/modal';
+import { UmbModalToken } from '@umbraco-cms/backoffice/modal';
+import { UUIFormControlMixinElement } from '@umbraco-ui/uui-base';
+
+/**
+ * Helper to create context item from serialized entity.
+ */
+export declare function createEntityContextItem(entity: UaiSerializedEntity): UaiRequestContextItem;
+
+/**
+ * Helper to create context item from user text selection.
+ */
+export declare function createSelectionContextItem(selectedText: string): UaiRequestContextItem;
+
+/**
+ * Dispatches an event through the action event context.
+ *
+ * Note: The host parameter uses `any` to avoid cross-package type coupling.
+ * When consumers import from different @umbraco-cms/backoffice instances,
+ * strict typing on UmbClassInterface causes TypeScript errors even with identical versions.
+ * @public
+ */
+export declare function dispatchActionEvent(host: any, event: Event): void;
+
+declare type EntityVersionComparisonResponseModel = {
+    fromVersion: number;
+    toVersion: number;
+    changes: Array<PropertyChangeModel>;
+};
+
+declare type EntityVersionHistoryResponseModel = {
+    currentVersion: number;
+    totalVersions: number;
+    versions: Array<EntityVersionResponseModel>;
+};
+
+declare type EntityVersionResponseModel = {
+    id: string;
+    entityId: string;
+    version: number;
+    dateCreated: string;
+    createdByUserId?: string | null;
+    createdByUserName?: string | null;
+    changeDescription?: string | null;
+};
+
+export declare function formatDateTime(input: string | Date, locale?: string): string;
+
+/**
+ * Check if an entity adapter is registered for the given entity type.
+ *
+ * @param entityType - The entity type to check (e.g., "document", "media")
+ * @returns True if an adapter is registered for this entity type
+ */
+export declare function hasEntityAdapter(entityType: string): boolean;
+
+/**
+ * Manifest for entity adapter extensions.
+ */
+export declare interface ManifestEntityAdapter extends ManifestBase {
+    type: typeof UAI_ENTITY_ADAPTER_EXTENSION_TYPE;
+    /** The entity type this adapter handles (e.g., "document", "media") */
+    forEntityType: string;
+    /** The adapter API class loader */
+    api: () => Promise<{
+        default: new () => UaiEntityAdapterApi;
+    }>;
+}
+
+declare type PropertyChangeModel = {
+    propertyName: string;
+    oldValue?: string | null;
+    newValue?: string | null;
+};
+
+/**
+ * Resolve an entity adapter by entity type.
+ *
+ * Looks up the extension registry for an adapter manifest matching the entity type,
+ * loads the adapter API module, and returns an instance.
+ *
+ * @param entityType - The entity type to find an adapter for (e.g., "document", "media")
+ * @returns The adapter instance, or undefined if no matching adapter is found
+ *
+ * @example
+ * ```typescript
+ * const entityType = workspaceContext.getEntityType();
+ * const adapter = await resolveEntityAdapterByType(entityType);
+ * if (adapter) {
+ *   const serialized = await adapter.serializeForLlm(workspaceContext);
+ * }
+ * ```
+ */
+export declare function resolveEntityAdapterByType(entityType: string): Promise<UaiEntityAdapterApi | undefined>;
+
+/**
+ * A constant representing an empty GUID.
+ * @public
+ */
+export declare const UAI_EMPTY_GUID = "00000000-0000-0000-0000-000000000000";
+
+/**
+ * Extension type alias for entity adapters.
+ */
+export declare const UAI_ENTITY_ADAPTER_EXTENSION_TYPE = "uaiEntityAdapter";
+
+export declare const UAI_ITEM_PICKER_MODAL: UmbModalToken<UaiItemPickerModalData, UaiItemPickerModalValue>;
+
+/**
+ * Modal token for the rollback confirmation modal.
+ */
+export declare const UAI_ROLLBACK_MODAL: UmbModalToken<UaiRollbackModalData, UaiRollbackModalValue>;
+
+/**
+ * Context token for consuming the Workspace Registry.
+ * Use this to access active workspaces from any component.
+ *
+ * @example
+ * ```typescript
+ * this.consumeContext(UAI_WORKSPACE_REGISTRY_CONTEXT, (context) => {
+ *   const workspaces = context.getAll();
+ *   context.changes$.subscribe(event => console.log(event));
+ * });
+ * ```
+ */
+export declare const UAI_WORKSPACE_REGISTRY_CONTEXT: UmbContextToken<UaiWorkspaceRegistryContext, UaiWorkspaceRegistryContext>;
+
+/**
+ * Configuration for the bulk delete action.
+ * @public
+ */
+export declare interface UaiBulkDeleteActionArgs {
+    /** Localization key or text for the dialog headline */
+    headline: string;
+    /** Localization key for the confirmation message (will be interpolated with count) */
+    confirmMessage: string;
+    /** Factory function to create the detail repository */
+    getRepository: (host: UmbControllerHost) => UmbDetailRepository<unknown>;
+}
+
+/**
+ * Reusable bulk delete action for Umbraco.AI entities.
+ * Extend this class and provide configuration via getArgs().
+ *
+ * Note: Event dispatching is handled by the repository for each deleted item.
+ * @public
+ */
+export declare abstract class UaiBulkDeleteActionBase extends UmbEntityBulkActionBase<never> {
+    #private;
+    /**
+     * Override this method to provide the bulk delete action configuration.
+     */
+    protected abstract getArgs(): UaiBulkDeleteActionArgs;
+    execute(): Promise<void>;
+}
+
+/**
+ * Public API for performing chat completions.
+ * @public
+ */
+export declare class UaiChatController extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    /**
+     * Performs a chat completion.
+     * @param messages - The conversation messages.
+     * @param options - Optional configuration (profile ID/alias, abort signal).
+     * @returns The AI response or error.
+     */
+    complete(messages: UaiChatMessage[], options?: UaiChatOptions): Promise<{
+        data?: UaiChatResult;
+        error?: unknown;
+    }>;
+}
+
+/**
+ * Represents a chat message.
+ * @public
+ */
+export declare interface UaiChatMessage {
+    role: UaiChatRole;
+    content: string;
+}
+
+/**
+ * Options for chat completion (public API).
+ * @public
+ */
+export declare interface UaiChatOptions {
+    /** Profile ID (GUID) or alias. If omitted, uses the default chat profile. */
+    profileIdOrAlias?: string;
+    /** AbortSignal for cancellation. */
+    signal?: AbortSignal;
+}
+
+/* Excluded from this release type: UaiChatRequest */
+
+/**
+ * Result of a chat completion.
+ * @public
+ */
+export declare interface UaiChatResult {
+    message: UaiChatMessage;
+    finishReason?: string | null;
+    usage?: UaiChatUsage | null;
+}
+
+/**
+ * Chat message role.
+ * @public
+ */
+export declare type UaiChatRole = 'user' | 'assistant' | 'system';
+
+/**
+ * Streaming chunk from chat completion.
+ * @public
+ */
+export declare interface UaiChatStreamChunk {
+    content: string;
+    finishReason?: string | null;
+}
+
+/**
+ * Token usage statistics.
+ * @public
+ */
+export declare interface UaiChatUsage {
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    totalTokens?: number | null;
+}
+
+/**
+ * Defines the contract for a command in the UAI system.
+ * @public
+ */
+export declare interface UaiCommand {
+    correlationId?: string;
+    execute(receiver: unknown): void;
+}
+
+/**
+ * Base class for UAI commands, providing common functionality.
+ * @public
+ */
+export declare abstract class UaiCommandBase<TReceiver> implements UaiCommand {
+    correlationId?: string;
+    constructor(correlationId?: string);
+    abstract execute(receiver: TReceiver): void;
+}
+
+/**
+ * A store for UaiCommand instances, allowing addition, retrieval, muting, and clearing of commands.
+ * @public
+ */
+export declare class UaiCommandStore {
+    #private;
+    add(command: UaiCommand): void;
+    getAll(): UaiCommand[];
+    mute(): void;
+    unmute(): void;
+    clear(): void;
+    reset(): void;
+}
+
+export declare class UaiContextPickerElement extends UaiContextPickerElement_base {
+    #private;
+    /**
+     * Allow selecting multiple contexts.
+     */
+    multiple: boolean;
+    /**
+     * Readonly mode - cannot add or remove.
+     */
+    readonly: boolean;
+    /**
+     * Minimum number of required contexts.
+     */
+    min?: number;
+    /**
+     * Maximum number of allowed contexts.
+     */
+    max?: number;
+    /**
+     * The selected context ID(s).
+     * - Single mode: string | undefined
+     * - Multiple mode: string[] | undefined
+     */
+    set value(val: string | string[] | undefined);
+    get value(): string | string[] | undefined;
+    private _selection;
+    private _items;
+    private _loading;
+    render(): TemplateResult<1>;
+    static styles: CSSResult[];
+}
+
+declare const UaiContextPickerElement_base: HTMLElementConstructor<UmbFormControlMixinElement<string | string[] | undefined>> & typeof UmbLitElement;
+
+/**
+ * Configuration for the delete action.
+ * @public
+ */
+export declare interface UaiDeleteActionArgs {
+    /** Localization key or text for the dialog headline */
+    headline: string;
+    /** Localization key or text for the confirmation message */
+    confirmMessage: string;
+    /** Factory function to create the detail repository */
+    getRepository: (host: UmbControllerHost) => UmbDetailRepository<unknown>;
+}
+
+/**
+ * Reusable delete action for Umbraco.AI entities.
+ * Extend this class and provide configuration via getArgs().
+ *
+ * Note: Event dispatching is handled by the repository, not the action.
+ * @public
+ */
+export declare abstract class UaiDeleteActionBase extends UmbEntityActionBase<never> {
+    /**
+     * Override this method to provide the delete action configuration.
+     */
+    protected abstract getArgs(): UaiDeleteActionArgs;
+    execute(): Promise<void>;
+}
+
+/**
+ * Detected entity with its adapter and workspace context.
+ * Used internally by the entity adapter context.
+ */
+export declare interface UaiDetectedEntity {
+    /** Unique key: entityType:unique */
+    key: string;
+    /** Display name for UI */
+    name: string;
+    /** Icon name for UI */
+    icon?: string;
+    /** Entity identity */
+    entityContext: UaiEntityContext;
+    /** The adapter that handles this entity */
+    adapter: UaiEntityAdapterApi;
+    /** Live workspace context instance */
+    workspaceContext: object;
+}
+
+/**
+ * Adapter for Umbraco document entities.
+ */
+export declare class UaiDocumentAdapter implements UaiEntityAdapterApi {
+    #private;
+    readonly entityType = "document";
+    /**
+     * Check if the workspace context is a document workspace.
+     * Uses duck-typing to check for document-specific methods.
+     */
+    canHandle(workspaceContext: unknown): boolean;
+    /**
+     * Extract entity identity from document workspace context.
+     */
+    extractEntityContext(workspaceContext: unknown): UaiEntityContext;
+    /**
+     * Get the current display name for the document.
+     */
+    getName(workspaceContext: unknown): string;
+    /**
+     * Get an observable for the document name for reactive updates.
+     * Uses the variants observable which properly tracks name changes.
+     */
+    getNameObservable(workspaceContext: unknown): Observable<string | undefined> | undefined;
+    /**
+     * Get the icon for the document from its content type.
+     * Returns undefined initially - use getIconObservable for reactive updates.
+     */
+    getIcon(workspaceContext: unknown): string | undefined;
+    /**
+     * Get an observable for the document icon for reactive updates.
+     * Uses the structure manager's ownerContentType observable to get the icon.
+     */
+    getIconObservable(workspaceContext: unknown): Observable<string | undefined> | undefined;
+    /**
+     * Serialize document for LLM context.
+     * Uses structure to get all properties, then merges with values.
+     * Only includes TextBox and TextArea properties for now.
+     */
+    serializeForLlm(workspaceContext: unknown): Promise<UaiSerializedEntity>;
+    /**
+     * Apply a property change to the document workspace.
+     * Changes are staged in the workspace - user must save to persist.
+     * Only supports text-based properties (TextBox, TextArea) for now.
+     */
+    applyPropertyChange(workspaceContext: unknown, change: UaiPropertyChange): Promise<UaiPropertyChangeResult>;
+}
+
+/**
+ * Editable model field for UI consumption.
+ */
+export declare interface UaiEditableModelFieldModel {
+    key: string;
+    label: string;
+    description?: string;
+    editorUiAlias?: string;
+    editorConfig?: unknown;
+    defaultValue?: unknown;
+    sortOrder: number;
+    isRequired: boolean;
+}
+
+/**
+ * Editable model schema for UI consumption.
+ */
+export declare interface UaiEditableModelSchemaModel {
+    type?: string;
+    fields: UaiEditableModelFieldModel[];
+}
+
+/**
+ * A single embedding vector with its index.
+ * @public
+ */
+export declare interface UaiEmbeddingItem {
+    index: number;
+    vector: number[];
+}
+
+/**
+ * Options for embedding generation (public API).
+ * @public
+ */
+export declare interface UaiEmbeddingOptions {
+    /** Profile ID (GUID) or alias. If omitted, uses the default embedding profile. */
+    profile?: string;
+    /** AbortSignal for cancellation. */
+    signal?: AbortSignal;
+}
+
+/* Excluded from this release type: UaiEmbeddingRequest */
+
+/**
+ * Result of an embedding generation request.
+ * @public
+ */
+export declare interface UaiEmbeddingResult {
+    embeddings: UaiEmbeddingItem[];
+}
+
+/**
+ * Public API for generating embeddings.
+ * @public
+ */
+export declare class UaiEmbeddingsController extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    /**
+     * Generates embeddings for a single value.
+     * @param value - The text to generate an embedding for.
+     * @param options - Optional configuration (profile ID/alias, abort signal).
+     * @returns The embedding vector or error.
+     */
+    generate(value: string, options?: UaiEmbeddingOptions): Promise<{
+        data?: number[];
+        error?: unknown;
+    }>;
+    /**
+     * Generates embeddings for multiple values.
+     * @param values - The texts to generate embeddings for.
+     * @param options - Optional configuration (profile ID/alias, abort signal).
+     * @returns The embedding result or error.
+     */
+    generateMany(values: string[], options?: UaiEmbeddingOptions): Promise<{
+        data?: UaiEmbeddingResult;
+        error?: unknown;
+    }>;
+}
+
+/**
+ * Custom event for Umbraco.AI entity actions.
+ * Dispatched by repositories after successful CRUD operations.
+ * @public
+ */
+export declare class UaiEntityActionEvent extends UmbEntityActionEvent {
+    static readonly CREATED = "uai-entity-created";
+    static readonly UPDATED = "uai-entity-updated";
+    static readonly DELETED = "uai-entity-deleted";
+    static created(unique: string, entityType: string): UaiEntityActionEvent;
+    static updated(unique: string, entityType: string): UaiEntityActionEvent;
+    static deleted(unique: string, entityType: string): UaiEntityActionEvent;
+    constructor(type: string, unique: string, entityType: string);
+}
+
+/**
+ * Entity adapter API interface.
+ * Adapters are responsible for:
+ * - Detecting if they can handle a workspace context
+ * - Extracting entity identity from workspace context
+ * - Serializing entity data for LLM consumption
+ * - Applying property changes (optional)
+ */
+export declare interface UaiEntityAdapterApi {
+    readonly entityType: string;
+    /**
+     * Check if this adapter can handle the given workspace context.
+     */
+    canHandle(workspaceContext: unknown): boolean;
+    /**
+     * Extract entity identity from workspace context.
+     */
+    extractEntityContext(workspaceContext: unknown): UaiEntityContext;
+    /**
+     * Get the current display name for the entity.
+     * Used for initial name population.
+     */
+    getName(workspaceContext: unknown): string;
+    /**
+     * Get an observable for the entity name for reactive updates.
+     * Returns undefined if the adapter doesn't support reactive names.
+     */
+    getNameObservable?(workspaceContext: unknown): Observable<string | undefined> | undefined;
+    /**
+     * Get the icon for the entity.
+     * Used for initial icon population.
+     */
+    getIcon?(workspaceContext: unknown): string | undefined;
+    /**
+     * Get an observable for the entity icon for reactive updates.
+     * Returns undefined if the adapter doesn't support reactive icons.
+     */
+    getIconObservable?(workspaceContext: unknown): Observable<string | undefined> | undefined;
+    /**
+     * Serialize the entity for LLM context.
+     */
+    serializeForLlm(workspaceContext: unknown): Promise<UaiSerializedEntity>;
+    /**
+     * Apply a property change to the workspace (staged, not persisted).
+     * Optional - some entity types may be read-only.
+     * @param workspaceContext The workspace context to modify
+     * @param change The property change to apply
+     * @returns Result indicating success or failure with error message
+     */
+    applyPropertyChange?(workspaceContext: unknown, change: UaiPropertyChange): Promise<UaiPropertyChangeResult>;
+}
+
+/**
+ * Context for entity adapter operations.
+ *
+ * Responsibilities:
+ * - Watch workspace registry for active workspaces
+ * - Match workspaces to entity adapters (from extension registry)
+ * - Track detected entities with adapters
+ * - Manage selected entity for context injection
+ * - Serialize selected entity for LLM context
+ */
+export declare class UaiEntityAdapterContext extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    destroy(): void;
+    /** Observable of all detected entities */
+    get detectedEntities$(): Observable<UaiDetectedEntity[]>;
+    /** Observable of the currently selected entity */
+    get selectedEntity$(): Observable<UaiDetectedEntity | undefined>;
+    /**
+     * Set the selected entity by key.
+     * Called by UI when user selects a different entity context.
+     */
+    setSelectedEntityKey(key: string | undefined): void;
+    /**
+     * Get all detected entities synchronously.
+     */
+    getDetectedEntities(): UaiDetectedEntity[];
+    /**
+     * Get the selected entity synchronously.
+     */
+    getSelectedEntity(): UaiDetectedEntity | undefined;
+    /**
+     * Serialize the selected entity for LLM context injection.
+     * Returns undefined if no entity is selected.
+     */
+    serializeSelectedEntity(): Promise<UaiSerializedEntity | undefined>;
+    /**
+     * Apply a property change to the currently selected entity.
+     * Changes are staged in the workspace - user must save to persist.
+     * @param change The property change to apply
+     * @returns Result indicating success or failure with error message
+     */
+    applyPropertyChange(change: UaiPropertyChange): Promise<UaiPropertyChangeResult>;
+}
+
+/**
+ * Entity Adapter Types
+ *
+ * Minimal interfaces for the entity adapter system that enables
+ * AI tools to interact with Umbraco entities being edited.
+ */
+/**
+ * Represents the identity of an entity being edited.
+ * Supports hierarchical relationships via recursive parentContext.
+ */
+export declare interface UaiEntityContext {
+    entityType: string;
+    unique: string | null;
+    parentContext?: UaiEntityContext;
+}
+
+/**
+ * Configuration for the entity deleted redirect controller.
+ * @public
+ */
+export declare interface UaiEntityDeletedRedirectArgs {
+    /** Function to get the current entity's unique identifier */
+    getUnique: () => string | undefined;
+    /** Function to get the current entity's type */
+    getEntityType: () => string | undefined;
+    /** Path to redirect to after the entity is deleted */
+    collectionPath: string;
+}
+
+/**
+ * Controller that redirects to the collection view when the current entity is deleted.
+ * Add this to workspace contexts that support deletion.
+ * @public
+ */
+export declare class UaiEntityDeletedRedirectController extends UmbControllerBase {
+    #private;
+    static readonly ALIAS = "UaiEntityDeletedRedirectController";
+    constructor(host: UmbControllerHost, args: UaiEntityDeletedRedirectArgs);
+}
+
+export declare interface UaiItemPickerModalData {
+    items?: UaiPickableItemModel[];
+    fetchItems?: () => Promise<UaiPickableItemModel[]>;
+    selectionMode?: 'single' | 'multiple';
+    tagTemplate?: (item: UaiPickableItemModel) => TemplateResult_2;
+    title?: string;
+    buttonLabel?: string;
+    noResultsMessage?: string;
+}
+
+export declare class UaiItemPickerModalElement extends UmbModalBaseElement<UaiItemPickerModalData, UaiItemPickerModalValue> {
+    #private;
+    private _loaded;
+    private _items;
+    private _filteredItems;
+    private _selectedItems;
+    connectedCallback(): Promise<void>;
+    render(): TemplateResult<1> | undefined;
+    static styles: CSSResult[];
+}
+
+export declare interface UaiItemPickerModalValue {
+    selection: UaiPickableItemModel[];
+}
+
+/**
+ * Event detail for model editor value changes.
+ */
+export declare interface UaiModelEditorChangeEventDetail {
+    model: Record<string, unknown>;
+}
+
+/**
+ * Reusable model editor component that renders a dynamic form based on a schema.
+ * Uses Umbraco's property dataset and property elements for rendering fields.
+ *
+ * @fires change - Fired when field values change
+ *
+ * @example
+ * ```html
+ * <uai-model-editor
+ *   .schema=${providerSchema}
+ *   .model=${currentSettings}
+ *   @change=${this.#onSettingsChange}>
+ * </uai-model-editor>
+ * ```
+ */
+export declare class UaiModelEditorElement extends UmbLitElement {
+    #private;
+    /**
+     * The schema defining the fields to render.
+     */
+    schema?: UaiEditableModelSchemaModel;
+    /**
+     * The current model values for the fields (key-value pairs).
+     */
+    model?: Record<string, unknown>;
+    /**
+     * Placeholder text shown when the schema has no fields.
+     */
+    emptyMessage?: string;
+    private _propertyValues;
+    shouldUpdate(changedProperties: Map<string, unknown>): boolean;
+    updated(changedProperties: Map<string, unknown>): void;
+    render(): TemplateResult<1>;
+    static styles: CSSResult[];
+}
+
+/**
+ * A command that updates a receiver object with a partial set of properties.
+ * @public
+ */
+export declare class UaiPartialUpdateCommand<TReceiver> extends UaiCommandBase<TReceiver> {
+    #private;
+    constructor(partial: Partial<TReceiver>, correlationId?: string);
+    execute(receiver: TReceiver): void;
+}
+
+export declare type UaiPickableItemModel = {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    meta?: any;
+};
+
+/**
+ * Profile picker component that allows selecting one or more AI profiles.
+ * Can be filtered by capability (e.g., "Chat", "Embedding").
+ *
+ * @fires change - Fires when the selection changes (UmbChangeEvent).
+ *
+ * @example
+ * Single selection (default):
+ * ```html
+ * <uai-profile-picker
+ *   capability="Chat"
+ *   .value=${"profile-id"}
+ *   @change=${(e) => console.log(e.target.value)}
+ * ></uai-profile-picker>
+ * ```
+ * Multiple selection:
+ * ```html
+ * <uai-profile-picker
+ *   multiple
+ *   .value=${["profile-id-1", "profile-id-2"]}
+ *   @change=${(e) => console.log(e.target.value)}
+ * ></uai-profile-picker>
+ * ```
+ * @public
+ */
+export declare class UaiProfilePickerElement extends UaiProfilePickerElement_base {
+    #private;
+    /**
+     * Filter profiles by capability. If not set, all profiles are shown.
+     */
+    capability?: string;
+    /**
+     * Allow selecting multiple profiles.
+     */
+    multiple: boolean;
+    /**
+     * Readonly mode - cannot add or remove.
+     */
+    readonly: boolean;
+    /**
+     * Minimum number of required profiles.
+     */
+    min?: number;
+    /**
+     * Maximum number of allowed profiles.
+     */
+    max?: number;
+    /**
+     * The selected profile ID(s).
+     * - Single mode: string | undefined
+     * - Multiple mode: string[] | undefined
+     */
+    set value(val: string | string[] | undefined);
+    get value(): string | string[] | undefined;
+    private _selection;
+    private _items;
+    private _loading;
+    render(): TemplateResult<1>;
+    static styles: CSSResult[];
+}
+
+declare const UaiProfilePickerElement_base: HTMLElementConstructor<UmbFormControlMixinElement<string | string[] | undefined>> & typeof UmbLitElement;
+
+/**
+ * Request to change a property value.
+ * Changes are staged in the workspace - user must save to persist.
+ */
+export declare interface UaiPropertyChange {
+    /** Property alias */
+    alias: string;
+    /** New value to set */
+    value: unknown;
+    /** Culture for variant content (undefined = invariant) */
+    culture?: string;
+    /** Segment for segmented content (undefined = no segment) */
+    segment?: string;
+}
+
+/**
+ * Result of a property change operation.
+ */
+export declare interface UaiPropertyChangeResult {
+    /** Whether the change was applied successfully */
+    success: boolean;
+    /** Human-readable error message if failed */
+    error?: string;
+}
+
+/**
+ * Request Context Types
+ *
+ * Simple context item interface for passing context to AI operations.
+ * Matches the backend AIRequestContextItem model.
+ */
+/**
+ * Simple context item - matches backend AIRequestContextItem.
+ * Intentionally flexible - processors on backend extract meaning.
+ */
+export declare interface UaiRequestContextItem {
+    /** Human-readable description */
+    description: string;
+    /** The context data */
+    value?: string;
+}
+
+/**
+ * Data passed to the rollback modal.
+ */
+export declare interface UaiRollbackModalData {
+    /** The source version being compared (the version to rollback to). */
+    fromVersion: number;
+    /** The target version being compared (usually the current version). */
+    toVersion: number;
+    /** The list of property changes between the versions. */
+    changes: UaiVersionPropertyChange[];
+}
+
+/**
+ * Value returned from the rollback modal.
+ */
+export declare interface UaiRollbackModalValue {
+    /** Whether the user confirmed the rollback. */
+    rollback: boolean;
+}
+
+/**
+ * Event emitted when an item is selected.
+ * @public
+ */
+export declare class UaiSelectedEvent extends Event {
+    static readonly TYPE = "selected";
+    unique: string | null;
+    item: any;
+    constructor(unique: string | null, item?: any, args?: EventInit);
+}
+
+/**
+ * Serialized representation of an entity for LLM context.
+ */
+export declare interface UaiSerializedEntity {
+    entityType: string;
+    unique: string;
+    name: string;
+    contentType?: string;
+    /** Parent unique when creating a new entity. Undefined for existing entities. */
+    parentUnique?: string | null;
+    properties: UaiSerializedProperty[];
+}
+
+/**
+ * Serialized property for LLM context.
+ */
+export declare interface UaiSerializedProperty {
+    alias: string;
+    label: string;
+    editorAlias: string;
+    value: unknown;
+}
+
+/**
+ * Response model for tag lookup results.
+ * @public
+ */
+export declare interface UaiTagItem {
+    /** Unique identifier for the tag */
+    id: string;
+    /** Display text of the tag */
+    text: string;
+    /** Optional group the tag belongs to */
+    group?: string;
+}
+
+/**
+ * Callback type for looking up existing tags.
+ * @param query - The search query string
+ * @returns Promise resolving to an array of matching tag items
+ * @public
+ */
+export declare type UaiTagLookupCallback = (query: string) => Promise<UaiTagItem[]>;
+
+/**
+ * A configurable tags input component that allows creating and selecting tags.
+ * The tag lookup mechanism is configurable via a callback function.
+ *
+ * @fires change - Fires when tags are added or removed
+ *
+ * @example
+ * ```html
+ * <uai-tags-input
+ *   .items=${['tag1', 'tag2']}
+ *   .lookup=${async (query) => {
+ *     const response = await fetch(`/api/tags?q=${query}`);
+ *     return response.json();
+ *   }}
+ *   @change=${(e) => console.log(e.target.items)}
+ * ></uai-tags-input>
+ * ```
+ *
+ * @example Strict mode - only allow values from suggestions
+ * ```html
+ * <uai-tags-input
+ *   strict
+ *   .lookup=${async (query) => fetchAllowedTags(query)}
+ *   @change=${(e) => console.log(e.target.items)}
+ * ></uai-tags-input>
+ * ```
+ * @public
+ */
+export declare class UaiTagsInputElement extends UaiTagsInputElement_base {
+    #private;
+    /**
+     * Callback function for looking up existing tags.
+     * When provided, enables autocomplete suggestions as the user types.
+     */
+    lookup?: UaiTagLookupCallback;
+    required: boolean;
+    requiredMessage: string;
+    set items(newTags: string[]);
+    get items(): string[];
+    /**
+     * Sets the input to readonly mode, meaning value cannot be changed but still able to read and select its content.
+     * @type {boolean}
+     * @attr
+     * @default false
+     */
+    readonly: boolean;
+    /**
+     * Placeholder text shown in the input field.
+     * @type {string}
+     * @attr
+     * @default 'Enter tag'
+     */
+    placeholder: string;
+    /**
+     * When enabled, only allows values that come from the lookup suggestions.
+     * Users cannot create arbitrary tags - they must select from the dropdown.
+     * @type {boolean}
+     * @attr
+     * @default false
+     */
+    strict: boolean;
+    private _matches;
+    private _currentInput;
+    private _mainTag;
+    private _tagInput;
+    private _widthTracker;
+    private _optionCollection?;
+    private _tagEls?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    focus(): void;
+    protected getFormElement(): undefined;
+    protected updated(): void;
+    /** Render */
+    render(): TemplateResult<1>;
+    static styles: CSSResult[];
+}
+
+declare const UaiTagsInputElement_base: (new (...args: any[]) => UUIFormControlMixinElement<FormData | FormDataEntryValue>) & typeof UmbLitElement;
+
+/**
+ * Unified repository for version history operations across all entity types.
+ * Uses the unified versioning API endpoint instead of entity-specific endpoints.
+ */
+export declare class UaiUnifiedVersionHistoryRepository {
+    #private;
+    constructor(host: UmbControllerHost);
+    /**
+     * Gets the version history for an entity.
+     * @param entityType - The type of entity (profile, connection, context).
+     * @param entityId - The entity ID.
+     * @param skip - Number of versions to skip (for pagination).
+     * @param take - Number of versions to return.
+     * @returns The version history response.
+     */
+    getVersionHistory(entityType: string, entityId: string, skip: number, take: number): Promise<UaiVersionHistoryResponse | undefined>;
+    /**
+     * Compares two versions of an entity.
+     * @param entityType - The type of entity (profile, connection, context).
+     * @param entityId - The entity ID.
+     * @param fromVersion - The source version number.
+     * @param toVersion - The target version number.
+     * @returns The comparison response with property changes.
+     */
+    compareVersions(entityType: string, entityId: string, fromVersion: number, toVersion: number): Promise<UaiVersionComparisonResponse | undefined>;
+    /**
+     * Rolls back an entity to a previous version.
+     * @param entityType - The type of entity (profile, connection, context).
+     * @param entityId - The entity ID.
+     * @param version - The version number to rollback to.
+     * @returns True if rollback was successful.
+     */
+    rollback(entityType: string, entityId: string, version: number): Promise<boolean>;
+}
+
+/**
+ * Response model for version comparison.
+ */
+export declare interface UaiVersionComparisonResponse {
+    /** The source version number. */
+    fromVersion: number;
+    /** The target version number. */
+    toVersion: number;
+    /** The list of property changes. */
+    changes: UaiVersionPropertyChange[];
+}
+
+/**
+ * Represents a single version history item.
+ */
+export declare interface UaiVersionHistoryItem {
+    /** The unique identifier of this version record. */
+    id: string;
+    /** The ID of the entity this version belongs to. */
+    entityId: string;
+    /** The version number (1, 2, 3, etc.). */
+    version: number;
+    /** The date and time when this version was created. */
+    dateCreated: string;
+    /** The user ID who created this version, if available. */
+    createdByUserId?: string | null;
+    /** The user name who created this version, if available. */
+    createdByUserName?: string | null;
+    /** Optional description of what changed in this version. */
+    changeDescription?: string | null;
+}
+
+/**
+ * Response model for version history with pagination info.
+ */
+export declare interface UaiVersionHistoryResponse {
+    /** The current version of the entity. */
+    currentVersion: number;
+    /** Total number of versions. */
+    totalVersions: number;
+    /** The versions in this page. */
+    versions: UaiVersionHistoryItem[];
+}
+
+export declare const UaiVersionHistoryTypeMapper: {
+    mapToVersionHistoryResponse(data: EntityVersionHistoryResponseModel): UaiVersionHistoryResponse;
+    mapToComparisonResponse(data: EntityVersionComparisonResponseModel): UaiVersionComparisonResponse;
+};
+
+/**
+ * Represents a property change between two versions.
+ */
+export declare interface UaiVersionPropertyChange {
+    /** The name of the property that changed. */
+    propertyName: string;
+    /** The old value (from the source version). */
+    oldValue?: string | null;
+    /** The new value (from the target version). */
+    newValue?: string | null;
+}
+
+/**
+ * Global context providing workspace registry functionality.
+ * Registered as a globalContext manifest - auto-instantiated at backoffice root.
+ */
+export declare class UaiWorkspaceRegistryContext extends UmbControllerBase {
+    #private;
+    /** Type guard marker for context resolution. */
+    readonly IS_WORKSPACE_REGISTRY_CONTEXT = true;
+    constructor(host: UmbControllerHost);
+    /** Observable of workspace change events */
+    get changes$(): Observable_2<WorkspaceChangeEvent>;
+    /** Get a workspace by its entity type and unique ID */
+    getByEntity(entityType: string, unique: string): WorkspaceEntry | undefined;
+    /** Get all registered workspaces */
+    getAll(): WorkspaceEntry[];
+    /* Excluded from this release type: _register */
+    /* Excluded from this release type: _rekey */
+    /* Excluded from this release type: _unregister */
+}
+
+/**
+ * Event emitted when workspace registration changes
+ */
+export declare interface WorkspaceChangeEvent {
+    type: "added" | "removed" | "updated";
+    key: string;
+    entry: WorkspaceEntry;
+}
+
+/**
+ * Represents a registered workspace context
+ */
+export declare interface WorkspaceEntry {
+    /** The workspace context instance */
+    context: object;
+    /** The manifest alias (e.g., "Umb.Workspace.Document") */
+    alias: string;
+    /** Entity type (e.g., "document", "media", "block") */
+    entityType: string | undefined;
+    /** Entity unique ID (GUID) */
+    entityUnique: string | undefined;
+}
+
+export { }