@epam/ai-dial-chat-hooks 1.2.0-dev.3 → 1.2.0-dev.303

package/index.d.ts

@@ -1,5 +1,8 @@
 import { Annotation } from '@epam/ai-dial-chat-shared';
 import { AnnotationGroup } from '@epam/ai-dial-quotations';
+import { ApplicationExternalServiceDto } from '@epam/ai-dial-chat-api-client';
+import { ApplicationSchemaSummaryDto } from '@epam/ai-dial-chat-api-client';
+import { ApplicationVisualizer } from '@epam/ai-dial-chat-shared';
 import { ArchiveItemDto } from '@epam/ai-dial-chat-api-client';
 import { Attachment } from '@epam/ai-dial-chat-shared';
 import { AttachmentDisplayResolvers } from '@epam/ai-dial-chat-shared';
@@ -8,6 +11,7 @@ import { AttachmentErrorReason } from '@epam/ai-dial-chat-shared';
 import { AttachmentResource } from '@epam/ai-dial-chat-shared';
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { CatalogContentTreeNode } from '@epam/ai-dial-catalog';
+import { CatalogCreateSearch } from '@epam/ai-dial-catalog';
 import { CatalogEntityType } from '@epam/ai-dial-chat-shared';
 import { CatalogItem } from '@epam/ai-dial-catalog';
 import { CatalogItemApiDetails } from '@epam/ai-dial-catalog';
@@ -25,6 +29,7 @@ import { ConversationTransferJob } from '@epam/ai-dial-chat-shared';
 import { ConversationTransferWarningCode } from '@epam/ai-dial-chat-shared';
 import { CopyFilesResponseDto } from '@epam/ai-dial-chat-api-client';
 import { CopyItemDto } from '@epam/ai-dial-chat-api-client';
+import { CreatedScheduledTaskDto } from '@epam/ai-dial-chat-api-client';
 import { CreateFolderDto } from '@epam/ai-dial-chat-api-client';
 import { CreateFolderResponseDto } from '@epam/ai-dial-chat-api-client';
 import { CreateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
@@ -34,8 +39,6 @@ import type { CustomVisualizerDataLayout } from '@epam/ai-dial-chat-shared';
 import { DeleteFilesResponseDto } from '@epam/ai-dial-chat-api-client';
 import { DeleteItemDto } from '@epam/ai-dial-chat-api-client';
 import { DeploymentConfigurationSchema } from '@epam/ai-dial-chat-shared';
-import { DeploymentCreationFormLocaleEntry } from '@epam/ai-dial-builder-form';
-import { DeploymentCreationFormLocaleOption } from '@epam/ai-dial-builder-form';
 import { DeploymentDetailsDto } from '@epam/ai-dial-chat-api-client';
 import { DeploymentFeatures } from '@epam/ai-dial-chat-shared';
 import { DeploymentItemDto } from '@epam/ai-dial-chat-api-client';
@@ -59,22 +62,33 @@ import { Dispatch } from 'react';
 import { DisplayAttachment } from '@epam/ai-dial-chat-shared';
 import { DropdownItem } from '@epam/ai-dial-ui-kit';
 import { ExportFolder } from '@epam/ai-dial-chat-shared';
+import { ExternalServicesApi } from '@epam/ai-dial-chat-api-client';
 import { FileManagerColumnKey } from '@epam/ai-dial-react-file-manager';
+import { FileManagerSelectableNode } from '@epam/ai-dial-chat-shared';
 import { FileMetadataResponseDto } from '@epam/ai-dial-chat-api-client';
 import { FilesApi } from '@epam/ai-dial-chat-api-client';
+import { FileTreeOptions } from '@epam/ai-dial-react-file-manager';
 import { FileUploadBatchState } from '@epam/ai-dial-chat-shared';
 import { FileUploadEntry } from '@epam/ai-dial-chat-shared';
 import { FileUploadResponseDto } from '@epam/ai-dial-chat-api-client';
 import { FileUploadStatus } from '@epam/ai-dial-chat-shared';
 import { FileUploadValidationResult } from '@epam/ai-dial-chat-shared';
+import { FilterChipItem } from '@epam/ai-dial-ui-kit';
 import { FilterTab } from '@epam/ai-dial-chat-shared';
-import { getParentFolderPath } from '@epam/ai-dial-chat-shared';
+import type { GroupedAttachmentItem } from '@epam/ai-dial-chat-shared';
+import { Implementation } from '@modelcontextprotocol/sdk/types.js';
 import type { InputHighlightData } from '@epam/pdf-highlighter-kit';
+import { LimitStatsDto } from '@epam/ai-dial-chat-api-client';
 import { ListFilesItemDto } from '@epam/ai-dial-chat-api-client';
 import { ListFilesResponseDto } from '@epam/ai-dial-chat-api-client';
 import { ListPublicFilesRequest } from '@epam/ai-dial-chat-api-client';
+import { ListScheduledTaskRunsResponseDto } from '@epam/ai-dial-chat-api-client';
+import { ListScheduledTasksResponseDto } from '@epam/ai-dial-chat-api-client';
+import { ListScheduledTasksSortEnum } from '@epam/ai-dial-chat-api-client';
 import { ListSharedFilesRequest } from '@epam/ai-dial-chat-api-client';
+import { LocaleOption } from '@epam/ai-dial-chat-shared';
 import { LocaleTextEntryDto } from '@epam/ai-dial-chat-api-client';
+import { LocalizedTextEntry } from '@epam/ai-dial-chat-shared';
 import { McpAppToolSummaryDto } from '@epam/ai-dial-chat-api-client';
 import { McpUiHostContext } from '@mcp-ui/client';
 import { Message } from '@epam/ai-dial-chat-shared';
@@ -82,10 +96,13 @@ import { MessageAttachment } from '@epam/ai-dial-chat-shared';
 import { MessageCustomContent } from '@epam/ai-dial-chat-shared';
 import { MessageRating } from '@epam/ai-dial-chat-shared';
 import { Middleware } from '@epam/ai-dial-chat-api-client';
+import { ModelLimitPeriodStatuses } from '@epam/ai-dial-usage-dashboard';
+import { ModelLimitRow } from '@epam/ai-dial-usage-dashboard';
 import { MoveFilesResponseDto } from '@epam/ai-dial-chat-api-client';
 import { MoveItemDto } from '@epam/ai-dial-chat-api-client';
 import { MutableRefObject } from 'react';
 import { NotificationVariant } from '@epam/ai-dial-ui-kit';
+import { OfflineCredentialsApi } from '@epam/ai-dial-chat-api-client';
 import { OverlayChatMessage } from '@epam/ai-dial-chat-overlay';
 import { PromptFolderResponseDto } from '@epam/ai-dial-chat-api-client';
 import { PromptListResponseDto } from '@epam/ai-dial-chat-api-client';
@@ -111,6 +128,10 @@ import { RevokeAccessItemDto } from '@epam/ai-dial-chat-api-client';
 import { RevokeAccessResponseDto } from '@epam/ai-dial-chat-api-client';
 import { ScheduledTaskCreateFormValues } from '@epam/ai-dial-scheduled-tasks';
 import { ScheduledTaskDto } from '@epam/ai-dial-chat-api-client';
+import { ScheduledTaskRunDto } from '@epam/ai-dial-chat-api-client';
+import { ScheduledTaskValidationErrors } from '../../libs/scheduled-tasks/validation';
+import { ScheduledTaskValidationOptions } from '../../libs/scheduled-tasks/validation';
+import { ScheduleTriggerDto } from '@epam/ai-dial-chat-api-client';
 import { SendCompletionDtoModeEnum } from '@epam/ai-dial-chat-api-client';
 import { SetStateAction } from 'react';
 import { ShareApi } from '@epam/ai-dial-chat-api-client';
@@ -122,16 +143,16 @@ import { SkillEditorFileActions } from '@epam/ai-dial-skill-editor';
 import { SkillEditorValues } from '@epam/ai-dial-skill-editor';
 import { SkillFileBatchError } from '@epam/ai-dial-skill-editor';
 import { SkillFileListResponseDto } from '@epam/ai-dial-chat-api-client';
+import { SkillFileSourceEntry } from '@epam/ai-dial-skill-editor';
 import { SkillFileTreeNode } from '@epam/ai-dial-skill-editor';
 import { SkillFileUploadCandidate } from '@epam/ai-dial-skill-editor';
 import { SkillFileValidationResult } from '@epam/ai-dial-skill-editor';
 import { SkillMetadataItemDto } from '@epam/ai-dial-chat-api-client';
 import { SkillUploadResponseDto } from '@epam/ai-dial-chat-api-client';
+import { Stage } from '@epam/ai-dial-chat-shared';
 import { StarterOption } from '@epam/ai-dial-chat-shared';
 import { StatusMessage } from '@epam/ai-dial-chat-shared';
 import { StreamChunk } from '@epam/ai-dial-chat-shared';
-import { TabModel } from '@epam/ai-dial-ui-kit';
-import { ToolbarOptions } from '@epam/ai-dial-react-file-manager';
 import { ToolMenuItem } from '@epam/ai-dial-chat-shared';
 import { ToolsetLoginBodyDto } from '@epam/ai-dial-chat-api-client';
 import { ToolsetLogoutBodyDto } from '@epam/ai-dial-chat-api-client';
@@ -139,9 +160,12 @@ import { ToolsetsApi } from '@epam/ai-dial-chat-api-client';
 import { TranscriptionApi } from '@epam/ai-dial-chat-api-client';
 import { UnpublishCatalogEntityDto } from '@epam/ai-dial-chat-api-client';
 import { UnpublishResultDto } from '@epam/ai-dial-chat-api-client';
+import { UpdatedScheduledTaskDto } from '@epam/ai-dial-chat-api-client';
 import { UpdateScheduledTaskBodyDto } from '@epam/ai-dial-chat-api-client';
 import { UploadArchiveResponseDto } from '@epam/ai-dial-chat-api-client';
 import { UploadedAttachmentResult } from '@epam/ai-dial-chat-shared';
+import { UsageLimitCardData } from '@epam/ai-dial-usage-dashboard';
+import { UsageLimitProgressRow } from '@epam/ai-dial-catalog';
 import { useGridEditingScroll } from '@epam/ai-dial-chat-shared';
 import { UseGridEditingScrollOptions } from '@epam/ai-dial-chat-shared';
 import { UseGridEditingScrollResult } from '@epam/ai-dial-chat-shared';
@@ -161,6 +185,7 @@ export declare interface AgentCapabilities {
     hasConfiguration?: boolean;
     hasChatCompletion?: boolean;
     hasResponsesApi?: boolean;
+    hasSkills?: boolean;
 }
 
 /** Input-attachment configuration for an agent (application) deployment. */
@@ -203,6 +228,9 @@ export declare const annotationToOoxmlCanvasContent: (annotation: Annotation, an
 /**
  * Builds a `PdfCanvasContent` for a PDF citation annotation, including highlights
  * for the clicked annotation's document within its citation group.
+ * When the clicked annotation has a page but no selector with valid geometry,
+ * an invisible page-anchor highlight is added and selected so the viewer
+ * still opens that page.
  * Returns `null` if the annotation has no PDF source attachment.
  */
 export declare const annotationToPdfCanvasContent: (annotation: Annotation, groups: AnnotationGroup[], resolvers: AttachmentCanvasUrlResolvers) => PdfCanvasContent | null;
@@ -212,21 +240,72 @@ export declare interface AnnouncementContent {
     title: string | null;
     description: string | null;
     html: string | null;
+    /** Entries of the popover the banner opens. */
+    items?: readonly AnnouncementListItem[];
+}
+
+/** One entry of the announcements popover behind the banner's `+N` pill. */
+export declare interface AnnouncementListItem {
+    /** Plain-text heading of the entry. */
+    title: string;
+    /** Supporting copy of the entry, sanitized before it is rendered. */
+    description?: string | null;
+    /** Optional call to action shown at the end of the entry. */
+    link?: AnnouncementListItemLink | null;
+}
+
+/** A link rendered as the call to action of an announcements-popover entry. */
+export declare interface AnnouncementListItemLink {
+    /** Visible text of the call to action. */
+    label: string;
+    /** Absolute `http`/`https` target the call to action opens. */
+    href: string;
 }
 
 /** Normalized shape returned by {@link getApiErrorDetails}. */
 export declare interface ApiErrorDetails {
+    /** Stable domain error code supplied by the API, when present. */
+    code?: string;
     /** HTTP status code carried by the error, when available. */
     status?: number;
     /** Resolved human-readable error message, or `null` when none could be resolved. */
     message: string | null;
     /** Extracted W3C trace ID, when the error's response carries a valid `traceparent`. */
     traceId?: string;
+    /**
+     * Error code reported by the service behind the API, when the API forwards one
+     * (`upstreamCode`). Passed through as-is; the host decides whether to act on it.
+     */
+    upstreamCode?: string;
+    /**
+     * Error reason reported by the service behind the API, when the API forwards one
+     * (`upstreamMessage`). Untranslated; the host decides whether to display it.
+     */
+    upstreamMessage?: string;
 }
 
 /** Appends a locale's uppercased code to a field label, e.g. `'Name [EN]'`. */
 export declare const appendLocaleCode: (label: string, locale: string) => string;
 
+/**
+ * Applies a single SSE stream chunk to the message list.
+ *
+ *
+ * Attachments are accumulated: each chunk's attachments are appended to the
+ * existing array rather than replacing it.
+ *
+ * Annotations are merged by `index`: partial `body.title` and `body.quote`
+ * strings are concatenated across chunks, matching the same delta-merge
+ * semantics used for stages.
+ *
+ * `state` is overwritten (not merged) by each chunk that carries one,
+ * matching the DIAL stateful-app contract.
+ *
+ * @returns Updated message array, or `null` when the chunk carries no
+ *   actionable data (empty content, no form_schema, and no attachments).
+ */
+export declare const applyChunkToMessages: (messages: Message[], messageIndex: number, chunk: StreamChunk) => Message[] | null;
+
 /** Converts an APScheduler weekday (Monday=0..Sunday=6) to a JS `Date` weekday (Sunday=0..Saturday=6). */
 export declare const apSchedulerDayToJsDay: (apSchedulerDay: number) => number;
 
@@ -279,6 +358,8 @@ export declare interface AttachmentCanvasUrlResolvers {
     resolveDialUrl: (attachment: DisplayAttachment) => string | undefined;
     /** Resolves a DIAL Core file id to a fetchable metadata URL (used for cache-freshness validation). */
     resolveDialFileMetadataUrl: (fileId: string) => string | undefined;
+    /** URL of a host-served bootstrap document that renders HTML with no download URL (inline `data`) under its own response CSP instead of the embedding page's — forwarded as `HtmlCanvasContent.srcdocHostUrl`. When omitted, that HTML renders via plain `srcdoc`. */
+    htmlSrcdocHostUrl?: string;
 }
 
 /** The type of content the canvas can display. */
@@ -294,6 +375,7 @@ declare enum AttachmentContentType {
     Code = 'code',
     Html = 'html',
     Visualizer = 'visualizer',
+    GroupedVisualizer = 'grouped_visualizer',
     McpApp = 'mcp_app',
     Unsupported = 'unsupported',
     Error = 'error',
@@ -325,10 +407,12 @@ export declare const attachmentToDto: (attachment: Attachment) => AttachmentDto;
 export declare interface AttachmentValidationErrorEvent {
     /** Why the attachment(s) were rejected. */
     reason: AttachmentValidationErrorReason;
-    /** The resolved MIME types the caller currently allows (possibly empty). */
-    allowedMimeTypes: string[];
+    /** The resolved MIME types the caller currently allows (possibly empty). Present only when `reason` is `NoTypesAllowed` or `UnsupportedType`. */
+    allowedMimeTypes?: string[];
     /** Already-formatted, non-translated extension list (e.g. ".png, .jpg"), present only when `reason` is `UnsupportedType`. */
     formats?: string;
+    /** The size limit, in bytes, that was exceeded. Present only when `reason` is `FileTooLarge`. */
+    maxFileSizeBytes?: number;
 }
 
 /** Reason a rejected attachment failed validation. */
@@ -336,7 +420,9 @@ export declare enum AttachmentValidationErrorReason {
     /** No MIME types are allowed at all — attachments are disabled entirely. */
     NoTypesAllowed = "noTypesAllowed",
     /** The attachment's content type is not among the allowed MIME types. */
-    UnsupportedType = "unsupportedType"
+    UnsupportedType = "unsupportedType",
+    /** The attachment's file size exceeds `maxFileSizeBytes`. */
+    FileTooLarge = "fileTooLarge"
 }
 
 /** Thrown by `transcribeAudio`; carries a machine-readable `reason` instead of translated text. */
@@ -353,7 +439,7 @@ export declare enum AudioTranscriptionErrorReason {
     Unavailable = "unavailable",
     /** The recording exceeds the caller's configured size limit. */
     TooLarge = "tooLarge",
-    /** The upstream ASR provider stayed rate-limited or unavailable after retrying. */
+    /** Recognition is rate-limited, unavailable, or exhausted short gateway retries. */
     Busy = "busy",
     /** Recognition failed for any other reason. */
     Failed = "failed"
@@ -371,7 +457,7 @@ export declare enum AuthenticationType {
  * `additionalLocaleCodes` and excluding whichever code is already the
  * primary Name/Description field.
  */
-export declare const buildAdditionalLocaleOptions: (additionalLocaleCodes: string[], primaryLocale: string) => DeploymentCreationFormLocaleOption[];
+export declare const buildAdditionalLocaleOptions: (additionalLocaleCodes: string[], primaryLocale: string) => LocaleOption[];
 
 /**
  * Builds the value persisted under `StorageKey.TextOfClosedAnnouncement` when
@@ -379,9 +465,18 @@ export declare const buildAdditionalLocaleOptions: (additionalLocaleCodes: strin
  * hidden only while the current announcement produces the same signature, so
  * editing any part of it brings the banner back with no version counter.
  *
+ * Every piece of content the banner surface renders feeds the signature — the
+ * title, the description, and the popover entries behind the pill, which live
+ * inside the banner and are hidden along with it. Publishing a new entry in
+ * that list therefore invalidates an earlier dismissal on its own, even when
+ * the banner line itself is untouched.
+ *
  * A legacy-only announcement returns the raw HTML string — byte-identical to
  * what shipped before the structured fields existed — so dismissals recorded
- * by older builds keep working without a storage migration.
+ * by older builds keep working without a storage migration. `items` is left
+ * out of the payload entirely when the list is empty for the same reason: a
+ * deployment that never configured the popover keeps matching the signatures
+ * its users already have stored.
  */
 export declare const buildAnnouncementSignature: (content: AnnouncementContent) => string;
 
@@ -424,6 +519,8 @@ export declare const buildPromptOverview: (prompt: PromptResponseDto, labels: Pr
 /** Joins a folder path and a prompt name into the DIAL prompt path used as an id. */
 export declare const buildPromptPath: (folderId: string, name: string) => string;
 
+export declare const buildResetFields: (stats: LimitStatsDto, formatResetTime: FormatResetTime | undefined) => Pick<UsageLimitProgressRow, "resetLabel" | "resetIsoValue" | "resetAriaLabel">;
+
 /** Builds the Responses API endpoint URL for a deployment. */
 export declare const buildResponsesUrl: (baseUrl: string) => string;
 
@@ -449,7 +546,9 @@ export declare const buildSharedItemVirtualPath: (relativePath: string, rootLabe
  * itself) contributes no node. Every folder entry is attached under its own
  * stripped path so an empty grouping folder still appears; every file entry
  * attaches under the folder chain its stripped path implies, synthesizing
- * any intermediate folder the listing never enumerated on its own. A file
+ * any intermediate folder the listing never enumerated on its own. An
+ * empty-folder marker (`.dial_folder`) only proves its folder exists and
+ * never becomes a file node. A file
  * node's `id` is the listing entry's own (unstripped) path, so it round-trips
  * back to `downloadSkillFile` without being re-derived; a folder node's `id`
  * is the stripped path and only keys client-side expand/collapse state.
@@ -459,7 +558,10 @@ export declare const buildSkillContentTree: (files: SkillMetadataItemDto[], skil
 /**
  * Builds the ordered supporting-file paths and `Blob` payload
  * `createSkill`/`updateSkill` expect from the editor's file tree and
- * in-memory content map.
+ * in-memory content map. Every folder node with no descendant node gets a
+ * zero-byte `<folder>/.dial_folder` marker after the real files, so the
+ * empty folder survives the whole-skill write; a folder with content needs
+ * none, and a marker it had before is dropped by that same write.
  */
 export declare const buildSkillFilesPayload: (files: SkillFileTreeNode[], filesContent: Map<string, SkillFileContent>) => SkillFilesPayload;
 
@@ -493,6 +595,13 @@ export declare const buildSkillManifestFromFrontmatter: (baseFrontmatter: Record
  * authored it, when it last changed, and its file inventory. Grouping folders
  * in the file listing are excluded from both the count and the rows. Sizes are
  * not shown — the skill metadata carries no content-length field.
+ *
+ * `skill` is the authoritative `getSkillMetadata` response when that request
+ * fulfilled; the caller falls back to the catalog listing entry only when it
+ * rejected (`useSkillItemDetails`'s `onFetchSkillDetails`). Either way, this
+ * function never fills a gap in one source from the other — an absent
+ * `author` omits the row and an absent `updatedAt` leaves the updated row's
+ * value empty, exactly as `skill` carries it.
  */
 export declare const buildSkillOverview: (skill: SkillMetadataItemDto | undefined, files: SkillMetadataItemDto[], about: SkillAboutDetails | undefined, labels: SkillOverviewLabels) => CatalogItemOverview;
 
@@ -538,7 +647,6 @@ export declare interface CatalogDetailsApi extends SkillDetailsApi {
 
 /** Localized copy `useCatalogEditNavigation` needs for the Create menu and delete errors. */
 export declare interface CatalogEditNavigationLabels {
-    createQuickApp: string;
     createToolset: string;
     createCustomApp: string;
     createSkill: string;
@@ -576,9 +684,9 @@ export declare interface CatalogEditNavigationUrls {
     buildCustomAppEditUrl(appId: string): string;
     /** URL to create a new custom (schema-less) app. */
     buildCustomAppCreateUrl(): string;
-    /** URL to edit an existing quick app under the given schema. */
+    /** URL to edit an existing schema-based app (quick app or any other runner) under the given schema. */
     buildQuickAppEditUrl(schemaId: string, appId: string): string;
-    /** URL to create a new quick app under the given schema. */
+    /** URL to create a new schema-based app (quick app or any other runner) under the given schema. */
     buildQuickAppCreateUrl(schemaId: string): string;
 }
 
@@ -677,6 +785,7 @@ export declare interface ChatStreamApi {
     stopCompletion: (dto: {
         generationId: string;
         path: string;
+        content?: string;
     }) => Promise<void>;
 }
 
@@ -688,6 +797,13 @@ export declare interface ChatStreamCompletionOptions {
     signal?: AbortSignal;
 }
 
+/**
+ * Classifies an import request's HTTP status into a semantic outcome: 400/413/422 are
+ * archive-content problems, 409 is a name collision, 429 is rate limiting, 502/503 mean the
+ * backend is unavailable, and anything else (including no status at all) is generic.
+ */
+export declare const classifySkillArchiveImportError: (status: number | undefined) => SkillArchiveImportErrorKind;
+
 /** Clears all cached fetch results. Call this when leaving a conversation. */
 export declare const clearAttachmentCache: () => void;
 
@@ -714,7 +830,7 @@ export declare const COLUMNS_WITHOUT_AUTHOR: FileManagerColumnKey[];
  * `undefined` (not `[]`) when nothing remains, so a request untouched by
  * this feature stays byte-identical to today.
  */
-export declare const composeLocalePayload: (otherLocales: DeploymentCreationFormLocaleEntry[], primaryLocale: string) => LocaleTextEntryDto[] | undefined;
+export declare const composeLocalePayload: (otherLocales: LocalizedTextEntry[], primaryLocale: string) => LocaleTextEntryDto[] | undefined;
 
 /** Whether an export includes the conversation's attachments. */
 export declare enum ConversationExportMode {
@@ -730,6 +846,28 @@ export declare interface ConversationGenerationLifecycle {
     completeGeneration: (path: string, generationId: string) => void;
 }
 
+/** Labels and formatter callbacks for the conversation-input limits mapping utility. */
+export declare interface ConversationInputLimitsLabels {
+    /** Heading of the group listing the selected deployment's token limits. */
+    tokenGroup: string;
+    /** Heading of the group listing the caller's cost budget and spend against it. */
+    costGroup: string;
+    /** Label for the current-UTC-day row, used by both groups. */
+    periodDay: string;
+    /** Label for the current-UTC-week row, used by both groups. */
+    periodWeek: string;
+    /** Label for the current-UTC-month row, used by both groups. */
+    periodMonth: string;
+    /** Formats the combined used/total display value for a capped row. */
+    formatValueLabel: (used: string, total: string) => string;
+    /** Formats the ARIA label for a capped progress row. */
+    formatProgressAriaLabel: (params: {
+        label: string;
+        used: string;
+        total: string;
+    }) => string;
+}
+
 /** Stable reverse-lookup maps returned by `useConversationLookupMaps`. */
 export declare interface ConversationLookupMaps {
     /** Returns the raw context id for a panel-space conversation id, or `undefined` when not found. */
@@ -793,7 +931,7 @@ export declare interface ConversationStreamOverlayNotifier {
 }
 
 /** The exact `startStream` shape `useConversationStream` returns. */
-export declare type ConversationStreamStarter = (conversationPath: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum) => void;
+export declare type ConversationStreamStarter = (conversationPath: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum, options?: StartStreamOptions) => void;
 
 /**
  * Host-owned transport for the DIAL Core completion protocol. Implemented at
@@ -803,10 +941,14 @@ export declare type ConversationStreamStarter = (conversationPath: string, userC
 export declare interface ConversationStreamTransport {
     /** Starts a completion; delivers chunks/completion/error through `options`, aborted via `options.signal`. */
     streamCompletion(path: string, message: string | undefined, model: string, options: StreamCompletionOptions, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum, messageIndex?: number, clientChannelId?: string): void;
-    /** Requests the backend stop an active generation. */
+    /**
+     * Requests the backend stop an active generation. `content` is the answer text shown
+     * so far; the backend saves it for a generation whose text it does not hold.
+     */
     stopCompletion(params: {
         generationId: string;
         path: string;
+        content?: string;
     }): Promise<void>;
     /** Opens a stream of resource-update events for `path`, until aborted via `signal`. */
     watchConversation(path: string, signal: AbortSignal): Promise<ReadableStream<Uint8Array>>;
@@ -880,6 +1022,12 @@ export declare interface CreateChatStreamApiDeps {
     getTimezone?: () => string | undefined;
     /** `fetch` implementation to issue requests through. Defaults to the global `fetch`. */
     fetchImpl?: typeof fetch;
+    /**
+     * How long an open completion stream may go without receiving a byte
+     * (keepalive comments included) before it is reported as a
+     * {@link StreamInterruptedError}. Defaults to {@link DEFAULT_STREAM_IDLE_TIMEOUT_MS}.
+     */
+    idleTimeoutMs?: number;
 }
 
 /**
@@ -929,6 +1077,12 @@ export declare const createMessagePair: (content: string, customContent?: Messag
  */
 export declare const createPublishApiClient: (publishApi: PublishApi) => PublishApiClient;
 
+/**
+ * Composes scheduler operations over an already configured generated client.
+ * Authentication, base URL, CSRF, and retries remain host responsibilities.
+ */
+export declare const createScheduledTasksApiClient: (client: ScheduledTasksConfiguredClient) => ScheduledTasksApiClient;
+
 /**
  * Builds a generated-client `Middleware` that throws on 401, and on a
  * classified invalid-CSRF 403 refreshes the token and retries the original
@@ -991,6 +1145,15 @@ export declare type CsrfRefreshOutcome = {
 
 export declare const DATE_OPTIONS: Intl.DateTimeFormatOptions;
 
+/**
+ * Inverse of `encodeDeploymentId` — decodes each `/`-separated segment back
+ * to its raw, human-readable form. A segment that isn't valid
+ * percent-encoding is passed through unchanged rather than throwing, since
+ * this decodes externally-sourced ids (the settings iframe's postMessage
+ * protocol).
+ */
+export declare const decodeDeploymentId: (id: string) => string;
+
 /**
  * Inverse of `encodeToolsetId` — decodes each `/`-separated segment back to
  * its raw, human-readable form. A segment that isn't valid percent-encoding
@@ -1007,11 +1170,14 @@ export declare const decodeToolsetId: (id: string) => string;
  * present in either map, excluding `primaryLocale` — that key is already the
  * primary Name/Description field, not a row in the popup.
  */
-export declare const decomposeLocalizedFields: (displayName: LocalizedText | undefined, description: LocalizedText | undefined, primaryLocale: string) => DeploymentCreationFormLocaleEntry[];
+export declare const decomposeLocalizedFields: (displayName: LocalizedText | undefined, description: LocalizedText | undefined, primaryLocale: string) => LocalizedTextEntry[];
 
 /** Fallback text of a {@link GenerationConflictError} when no message is supplied. */
 export declare const DEFAULT_GENERATION_CONFLICT_MESSAGE = "A response is already being generated in this conversation. Wait for it to finish or stop it before sending another message.";
 
+/** Safe fallback for hosts that do not supply a translated persistence warning. */
+export declare const DEFAULT_GENERATION_PERSISTENCE_ERROR_MESSAGE = "The response could not be saved. It is still shown here, but may be lost if you reload or leave this page. Copy it before continuing.";
+
 /**
  * Default ceiling on the summed byte length of an export's attachments.
  *
@@ -1025,6 +1191,8 @@ export declare const DEFAULT_GENERATION_CONFLICT_MESSAGE = "A response is alread
  */
 export declare const DEFAULT_MAX_ARCHIVE_BYTES: number;
 
+export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 45000;
+
 /** Translated folder-path labels for the Personal/Shared/Public deployment groupings. */
 export declare interface DeploymentFolderLabels {
     personal: string;
@@ -1042,16 +1210,14 @@ export declare interface DeploymentGenerationApiSupport {
 export declare interface DeploymentLimitsLabels {
     /** Heading of the group every token stat row is listed under. */
     tokenGroup: string;
-    /** Label for the tokens-per-day stat row. */
+    /** Label for the current-UTC-day token row, e.g. "Today". */
     tokensPerDay: string;
-    /** Label for the tokens-per-week stat row. */
+    /** Label for the current-UTC-week token row, e.g. "This week". */
     tokensPerWeek: string;
-    /** Label for the tokens-per-month stat row. */
+    /** Label for the current-UTC-month token row, e.g. "This month". */
     tokensPerMonth: string;
     /** Note shown instead of a total on a row whose limit follows the cost limit. */
     followsCostLimit: string;
-    /** Formats the "$X spent" caption under a row's label. */
-    formatSpentCaption: (amount: string) => string;
     /** Formats the combined used/total display value for a capped row. */
     formatValueLabel: (used: string, total: string) => string;
     /** Formats the ARIA label for a capped progress row. */
@@ -1065,6 +1231,8 @@ export declare interface DeploymentLimitsLabels {
         label: string;
         used: string;
     }) => string;
+    /** Formats each period's `resetsAt` into the row's reset line. Omit it to render rows without one. */
+    formatResetTime?: FormatResetTime;
 }
 
 export declare const deriveActionProfile: (variant: DialFileManagerVariant) => DialFileManagerActionProfile;
@@ -1091,16 +1259,33 @@ export declare const deriveAvailableTabIds: <T extends CatalogEntityType>(items:
 export declare const deriveConversationRowActionState: (item: Pick<ConversationListItemDto, "sharedWithMe" | "publishedWithMe" | "isReadonly">, publishHistory: PublishHistoryEntry[] | undefined, recipients: RecipientsCountEntry) => ConversationRowActionState;
 
 /**
- * Returns items marked as a user favorite, in original order.
+ * Returns items marked as a user favorite that are not hidden, in original order.
  */
 export declare const deriveFavoriteItems: (items: readonly CatalogItem[]) => CatalogItem[];
 
+/**
+ * Describes the complete trigger without requiring unrelated task metadata.
+ * Unsupported constraints remain Custom, with the full source expression.
+ * Calendar-month shifts crossing month boundaries or days 29–31 remain
+ * Custom because a shifted monthly day is not equivalent around short months.
+ * The one exception is `day: 'last'` one day behind local time, which is
+ * exactly the local 1st.
+ */
+export declare const describeScheduledTaskTrigger: (trigger: ScheduleTriggerDto, { timeZone, referenceDate, }?: ScheduledTaskTriggerDescriptionOptions) => ScheduledTaskTriggerDescription;
+
+/** Source tabs `useDialFileManagerSections` can merge into the All tab, in display order. */
+export declare const DIAL_FILE_MANAGER_SECTION_TABS: readonly DialFileManagerTabs[];
+
 /** Strip the "files/{bucket}/" prefix from a DIAL Core URL to get the path within the bucket. */
 export declare const dialCorePathToRelative: (dialCorePath: string, bucket: string) => string;
 
-export { DialFileManagerActionProfile }
-
-export { DialFileManagerVariant }
+/** One source tab rendered as a top-level folder of the All view. */
+export declare interface DialFileManagerSection {
+    /** Source tab backing this section — `MyFiles`, `Shared` or `Organization`. */
+    tab: DialFileManagerTabs;
+    /** Display name of the section's top-level folder; also the first segment of its virtual paths. An empty, slash-containing or repeated label is replaced by the tab id. */
+    rootLabel: string;
+}
 
 /**
  * Operation port every file-manager hook that performs network I/O accepts as
@@ -1434,7 +1619,9 @@ export declare enum FileManagerNotificationReason {
     /** `onUploadArchive` extracted some entries successfully and some failed; `count`/`names`/`restCount` describe the failures. */
     UploadArchivePartiallyFailed = "uploadArchivePartiallyFailed",
     /** `onUploadArchive`'s `uploadArchive` request itself rejected. */
-    UploadArchiveRequestFailed = "uploadArchiveRequestFailed"
+    UploadArchiveRequestFailed = "uploadArchiveRequestFailed",
+    /** A copy/move targeted a destination in a different All-view section from its source items; no request was made. */
+    CrossSectionTransferUnsupported = "crossSectionTransferUnsupported"
 }
 
 /**
@@ -1455,8 +1642,6 @@ export declare type FileNameValidationError = {
 } | {
     reason: FileNameValidationErrorReason.DuplicateName;
     existingName: string;
-} | {
-    reason: FileNameValidationErrorReason.LeadingDot;
 };
 
 /**
@@ -1469,8 +1654,7 @@ export declare enum FileNameValidationErrorReason {
     ForbiddenSymbols = "forbiddenSymbols",
     ReservedName = "reservedName",
     TooLong = "tooLong",
-    DuplicateName = "duplicateName",
-    LeadingDot = "leadingDot"
+    DuplicateName = "duplicateName"
 }
 
 /**
@@ -1487,7 +1671,10 @@ export declare enum FileOperationKind {
     FileCopied = "fileCopied",
     FilesCopied = "filesCopied",
     FileMoved = "fileMoved",
-    FilesMoved = "filesMoved"
+    FilesMoved = "filesMoved",
+    /** A copy whose every item landed in its own source folder (Duplicate). */
+    FileDuplicated = "fileDuplicated",
+    FilesDuplicated = "filesDuplicated"
 }
 
 /**
@@ -1502,13 +1689,15 @@ export declare interface FileOperationSuccessEvent {
     name?: string;
     /** Number of items the operation covered, when applicable. */
     count?: number;
-    /** Destination folder name, for copy/move operations. */
+    /**
+     * Destination folder as a slash-joined virtual path starting at the root
+     * label (e.g. `My files/reports`), for copy/move/duplicate operations.
+     */
     destinationFolderName?: string;
     /**
-     * Whether the affected item is a folder rather than a file. Only set for
-     * `fileRenamed`, since it is the only kind whose current wording depends
-     * on the item's node type (a rename toast reads "Folder renamed" vs.
-     * "File renamed").
+     * Whether the affected item is a folder rather than a file. Set for rename,
+     * copy, move, and duplicate events; on a multi-item event it describes the
+     * first successfully affected item (the one `name` refers to).
      */
     isFolder?: boolean;
 }
@@ -1543,8 +1732,6 @@ export declare interface FilesApiClient {
     listSharedByMe: (bucket: string) => Promise<ListFilesResponseDto>;
 }
 
-export { FileUploadValidationResult }
-
 /**
  * Filters catalog items to those whose type is in `visibleTypes`.
  * Call only when selector mode is active; otherwise pass through the original array.
@@ -1606,6 +1793,9 @@ export declare const formatOperationFolderName: (destinationFolder: string, root
  */
 export declare const formatQuotedNameList: (names: string[]) => string;
 
+/** Formats a raw `resetsAt` into display strings, or returns `undefined` when it cannot be formatted. */
+export declare type FormatResetTime = (resetsAt: string | undefined) => ResetTimeDisplay | undefined;
+
 /**
  * Reported through `onError` when the backend rejects a completion because
  * another generation is already active on the same conversation — what a
@@ -1617,7 +1807,13 @@ export declare class GenerationConflictError extends Error {
     constructor(message?: string);
 }
 
-/** Normalizes any API error into a `{ status?, message, traceId? }` shape. */
+/** Identifies a failed terminal save independently of the model's generation outcome. */
+export declare class GenerationPersistenceError extends Error {
+    static readonly type = "conversation_save_failed";
+    constructor();
+}
+
+/** Normalizes any API error into a `{ status?, message, traceId?, code?, upstreamCode?, upstreamMessage? }` shape. */
 export declare const getApiErrorDetails: (error: unknown) => Promise<ApiErrorDetails>;
 
 /** Resolves a human-readable message from an API error's response body, or falls back to `Error.message`. */
@@ -1652,6 +1848,21 @@ export declare const getConversationSource: (item: Pick<ConversationListItemDto,
  */
 export declare const getExternalServiceFallbackName: (serviceName: string) => string;
 
+/**
+ * Returns the tool values the conversation's last message sets through its
+ * `form_schema`, restricted to `toolIds`, plus a key identifying that exact
+ * application. `undefined` when the last message is not an assistant message
+ * or sets no known tool.
+ *
+ * Streamed chunks and reloads re-create an identical `form_schema`; comparing
+ * keys rather than object identity applies an app's value once and leaves a
+ * later user toggle alone until the app sends a different value.
+ */
+export declare const getFormSchemaToolSyncKey: (conversationId: string, messages: Message[], toolIds: readonly string[]) => {
+    key: string;
+    values: Record<string, boolean>;
+} | undefined;
+
 /**
  * Returns the deployment the conversation was last running on: scanning
  * backwards, the `new_deployment_id` of a `model_changed` status message or
@@ -1662,7 +1873,7 @@ export declare const getExternalServiceFallbackName: (serviceName: string) => st
  * an edit truncates past one: the marker is appended at the end of the
  * timeline, so truncating at an earlier message drops it, and the model the
  * user picked reverted on the next page load even though the answer had been
- * regenerated on it (issue #8712). The assistant message the backend writes
+ * regenerated on it ([#8712](https://github.com/epam/ai-dial-chat/issues/8712)). The assistant message the backend writes
  * carries the deployment that produced it, which survives that truncation
  * because it *is* the regenerated message.
  */
@@ -1675,6 +1886,15 @@ export declare const getLastDeploymentId: (messages: Message[]) => string | null
  */
 export declare const getLastUserMessageToolConfiguration: (messages: Message[]) => Record<string, unknown> | undefined;
 
+/**
+ * Returns the tool configuration a (re-)loaded conversation should show: the
+ * last user message's `configuration_value`, overlaid in order by the
+ * `form_schema` values of the assistant messages after it. An app that turned
+ * a toggle off in its final response must not see it re-armed on reload just
+ * because the user message that started the run had it on.
+ */
+export declare const getLatestToolConfiguration: (messages: Message[]) => Record<string, unknown> | undefined;
+
 /**
  * Extracts the deployment/model ID from a DIAL Core conversation ID.
  *
@@ -1702,8 +1922,6 @@ export declare const getLastUserMessageToolConfiguration: (messages: Message[])
  */
 export declare const getModelIdFromConversationId: (id: string) => string | undefined;
 
-export { getParentFolderPath }
-
 /**
  * The publish folder a public catalog entity id sits in: the segments between
  * the `public` bucket and the entity name, decoded to the plain text the
@@ -1722,6 +1940,12 @@ export declare const getQuickAppConversationStarters: (conversationStarters: unk
  */
 export declare const getRemainingCharacters: (value: string, maxLength: number) => number | null;
 
+/** Returns the schemas that create schema-based apps: unique by id, without id-less entries or the custom-app schema. */
+export declare const getRunnerSchemas: <T extends QuickAppSchemaLike>(schemas: T[]) => RunnerSchema<T>[];
+
+/** Returns the limit each over-long skill field exceeds, keyed by field; fields within their limit are omitted. */
+export declare const getSkillFieldLengthViolations: (values: Record<SkillTextField, string>) => Partial<Record<SkillTextField, number>>;
+
 /**
  * Returns the text to start/populate a conversation from a selected starter button.
  * `description` (the schema property's shared intro/question text) is used only
@@ -1775,6 +1999,15 @@ export declare const getStarterSubmitText: (starter: StarterOption, description?
  */
 export declare const getTimeOfDayGreeting: (hour: number, translations: GreetingTranslations, firstName?: string) => string;
 
+/**
+ * Returns the boolean values an assistant message's `form_schema` sets, keyed
+ * by property name, or `undefined` when no property resolves to a boolean.
+ * Lets a DIAL app switch a tools-menu toggle (e.g. `deep_research`) per
+ * message — on while a run is in progress, off once its result is delivered.
+ * Not filtered by tool id: `restoreToolConfiguration` ignores unknown ids.
+ */
+export declare const getToolConfigurationFromFormSchema: (formSchema: DeploymentConfigurationSchema | undefined) => Record<string, boolean> | undefined;
+
 /** Name of the same-origin `BroadcastChannel` shared by an OAuth flow's opener and its callback popup. */
 export declare const getToolsetOAuthChannelName: (flowId: string) => string;
 
@@ -1809,6 +2042,30 @@ export declare interface GreetingTranslations {
     nightNoName: string;
 }
 
+/** Content payload for an application-scoped grouped visualizer: every attachment a message's visualizer claims, rendered together inside one sandboxed iframe. */
+declare interface GroupedVisualizerCanvasContent {
+    /** Discriminates the content type to select the correct renderer. */
+    type: AttachmentContentType.GroupedVisualizer;
+    /** Iframe `src`, resolved from the matching registry entry's `url`. */
+    url: string;
+    /** One item per claimed attachment, in the message's attachment order. Each `url` is absolute, resolved by the host. */
+    attachments: GroupedAttachmentItem[];
+    /** Presentation layout hints (`themeId`, `width`, `height`, `mobileHeight`) shared by every item. */
+    layout: CustomVisualizerDataLayout;
+    /** postMessage protocol namespace — MUST equal the registry entry's `title`, or the iframe never receives data. */
+    visualizerName: string;
+    /** Milliseconds to wait for a `send()` request's response before rejecting. From the registry entry; does NOT bound the handshake. */
+    requestTimeout?: number;
+}
+
+/** Outcome of building a grouped visualizer payload. */
+export declare interface GroupedVisualizerResolution {
+    /** The grouped payload, or `null` when no claimed attachment resolved to a URL. */
+    content: GroupedVisualizerCanvasContent | null;
+    /** The claimed attachments that reached `content.attachments`, in the input's order. The caller returns the rest to the ordinary attachment tray. */
+    resolved: DisplayAttachment[];
+}
+
 /** Whether at least one tool toggle in `value` is active. */
 export declare const hasActiveToolConfig: (value: Record<string, boolean> | undefined) => boolean;
 
@@ -1827,6 +2084,9 @@ export declare const hasDialFileWritePermission: (folder?: DialFile) => boolean;
 
 export declare const hasForbiddenNameSymbols: (name: string, forbiddenSymbolsRegExp?: RegExp) => boolean;
 
+/** Returns `true` when both sets contain exactly the same paths. */
+export declare const hasSamePaths: (a: ReadonlySet<string>, b: ReadonlySet<string>) => boolean;
+
 /**
  * Whether the operator configured the structured banner (title and/or
  * description) rather than only the legacy HTML message. Drives which of the
@@ -1838,10 +2098,16 @@ export declare const hasStructuredAnnouncement: ({ title, description, }: Announ
 declare interface HtmlCanvasContent {
     /** Discriminates the content type to select the correct renderer. */
     type: AttachmentContentType.Html;
-    /** Full HTML text rendered via `srcdoc` in a sandboxed iframe. Used for file attachments. */
+    /** Full HTML text rendered via `srcdoc` in a sandboxed iframe. Populated only when no `url` is available (local, non-downloadable file attachments); when `url` is set, "View source" instead calls `resolveSourceText`. */
     srcdoc?: string;
-    /** External URL rendered via `src` in a sandboxed iframe. Used for external link sources. */
+    /** URL rendered via `src` in a sandboxed iframe when `srcdoc` is absent, or in preference to `srcdoc` when `isSameOriginUrl` is set. Also used as the download-button/"Open in new tab" target. */
     url?: string;
+    /** True when `url`'s origin matches the embedding document's own origin. Forces the iframe sandbox to omit `allow-same-origin` — granting it would let a same-origin framed document reach this page's own cookies/storage — and makes `src` take precedence over `srcdoc`; also skips the `contentDocument` block-detection check, since the iframe is intentionally opaque-origin either way. */
+    isSameOriginUrl?: boolean;
+    /** Lazily fetches the full HTML source text for the "View source" toggle. Used instead of an eagerly-populated `srcdoc` when `url` is set; absent when `srcdoc` is already populated. */
+    resolveSourceText?: () => Promise<string>;
+    /** Host-served bootstrap document used to render `srcdoc` without inheriting the embedding page's CSP. When set alongside `srcdoc`, the iframe loads this URL via `src` (still `sandbox="allow-scripts"`) and posts `{ type: HTML_PREVIEW_FRAME_RENDER_MESSAGE, html: srcdoc }` to it once loaded, so the HTML renders under that response's own policy. Ignored when `srcdoc` is absent or `isSameOriginUrl` selects `url`. */
+    srcdocHostUrl?: string;
 }
 
 /** Content payload for image attachments. */
@@ -1875,11 +2141,12 @@ export declare const initiateOAuthLogin: (auth: ToolsetOAuthSettings, toolsetId:
 export declare const isAnswerIncomplete: (answer: Message | undefined) => boolean;
 
 /**
- * True when the conversation's last message is an unresolved assistant
- * placeholder: the backend only persists a conversation at generation start
- * (empty placeholder) and at generation end (final content, or a partial
- * flagged `streamErrorMessage`/`wasStoppedByUser`), so this shape means a
- * generation was still active elsewhere when the conversation was loaded.
+ * True when the conversation has a pending background message, or its last
+ * message is an unresolved assistant placeholder: the backend only persists a
+ * conversation at generation start (empty placeholder) and at generation end
+ * (final content, or a partial flagged `streamErrorMessage`/`wasStoppedByUser`).
+ * This can mean generation is still active elsewhere, or that its terminal save
+ * failed.
  */
 export declare const isAwaitingGenerationResume: (conversation: Conversation) => boolean;
 
@@ -1955,6 +2222,9 @@ export declare const isQuickAppSchema: (schema?: QuickAppSchemaLike) => boolean;
 /** Share/Unshare/Remove access are Full-only — Browse and Attach never expose them. */
 export declare const isShareActionsAllowed: (actionProfile: DialFileManagerActionProfile) => boolean;
 
+/** Whether a skill-relative path is a folder marker (`<folder>/.dial_folder`, never a root-level `.dial_folder`). */
+export declare const isSkillFolderMarkerPath: (path: string) => boolean;
+
 /** True when `value` is a well-formed absolute `http(s)://` URL. */
 export declare const isValidAbsoluteUrl: (value: string) => boolean;
 
@@ -1965,7 +2235,10 @@ export declare const isValidFeaturesData: (value: string) => boolean;
  * Client-side mirror of the backend's `isValidSkillRelativePath`
  * (`apps/chat-api/src/skills/utils/skill-path.util.ts`), used only for
  * immediate inline feedback — the server remains authoritative and may still
- * reject a path this function accepts.
+ * reject a path this function accepts. It additionally reserves the
+ * `.dial_folder` marker name so a user can never upload or name a folder
+ * after it; the save payload's generated markers never pass through here
+ * (the server accepts them only as a zero-byte final segment).
  */
 export declare const isValidSkillRelativePath: (relativePath: string) => boolean;
 
@@ -2014,8 +2287,8 @@ export declare const mapDeploymentDetailsDtoToEntityDetails: (dto: DeploymentDet
 /** Maps a deployment limits DTO to display-ready catalog limits, or `undefined` when no qualifying stats exist. */
 export declare const mapDeploymentLimitsDtoToCatalogLimits: (dto: DeploymentLimitsResponseDto | undefined, labels: DeploymentLimitsLabels) => CatalogItemLimits | undefined;
 
-/** Maps the monthly deployment token limit to a display-ready value. */
-export declare const mapDeploymentLimitsToInput: (dto: DeploymentLimitsResponseDto | undefined) => MonthlyUsageLimit | undefined;
+/** Maps a deployment's day, week, and month token limits and the caller's cost budget to display-ready rows, or `undefined` when none qualify. */
+export declare const mapDeploymentLimitsToInput: (dto: DeploymentLimitsResponseDto | undefined, labels: ConversationInputLimitsLabels, formatResetTime?: FormatResetTime) => CatalogItemLimits | undefined;
 
 /** Maps a deployment listing row into the catalog UI's `CatalogItem` shape. */
 export declare const mapDeploymentToCatalogItem: (deployment: DeploymentItemDto, { favoriteIds, entityDetails, folderLabels, editableSchemaIds, isCustomAppsEditable, activeLocale, primaryLocale, resolveIconUrl, }: MapDeploymentToCatalogItemOptions) => CatalogItem;
@@ -2081,12 +2354,18 @@ export declare const mapFileMetadataToDialFile: (metadata: FileMetadataResponseD
 export declare const mapFormValuesToCreateBody: (values: ScheduledTaskCreateFormValues) => CreateScheduledTaskBodyDto;
 
 /**
- * Maps validated edit-form values to the `PUT /api/v1/scheduled-tasks/:scheduleId`
- * request body. `UpdateScheduledTaskBodyDto` has the same shape as
- * `CreateScheduledTaskBodyDto`, so this reuses the same trigger-building logic.
+ * Maps a complete, validated edit draft to an update body. An unset skill
+ * emits null to remove the saved reference; hydrate from detail before editing.
  */
 export declare const mapFormValuesToUpdateBody: (values: ScheduledTaskCreateFormValues) => UpdateScheduledTaskBodyDto;
 
+/**
+ * Maps the same top-level Cost budgets used by the aggregate cards into table-header state.
+ *
+ * @param formatResetTime - Formats each period's top-level `resetsAt` into the header's reset trio. Omit it to produce statuses with no reset fields.
+ */
+export declare const mapOverallCostLimitsToPeriodStatuses: (usage: UserLimitStatsResponseDto | undefined, activeLocale: string, t: Translate_2, formatResetTime?: FormatResetTime) => ModelLimitPeriodStatuses;
+
 /**
  * Maps a prompt DTO into a catalog item.
  *
@@ -2145,6 +2424,16 @@ export declare interface MapSkillToCatalogItemOptions {
     favoriteIds: ReadonlySet<string>;
 }
 
+/**
+ * Returns the normalized stages of a complete raw stage array or a
+ * message-like payload (reading `custom_content.stages`, falling back to
+ * `customContent.stages`), or `undefined` when there are none. An entry
+ * without an `index` takes its array position — the identity a complete
+ * non-streaming array's `parent_stage_index` refers to — while explicit
+ * (possibly sparse) indexes are kept. Not for partial stream deltas.
+ */
+export declare const mapStages: (source: RawStage[] | RawStageSource | null | undefined) => Stage[] | undefined;
+
 /**
  * Maps a toolset's specification into the lib's credential-status shape,
  * for refreshing the details panel after login/logout. Includes both
@@ -2169,6 +2458,25 @@ export declare interface MapToolsetToCatalogItemOptions {
     resolveIconUrl: (iconUrl: string | undefined) => string | undefined;
 }
 
+/**
+ * Maps a `UserLimitStatsResponseDto` into `UsageLimitCardGroup`'s `cards` prop,
+ * in Today / This week / This month order. A period is omitted entirely when
+ * the response carries no usable stat for it. Each card's reset trio comes from
+ * `formatResetTime`, and is absent when that callback returns `undefined`.
+ */
+export declare const mapUsageDataToDashboard: (usage: UserLimitStatsResponseDto | undefined, t: Translate, formatResetTime: FormatResetTime) => UsageLimitCardData[];
+
+/**
+ * Maps `usage.deployments` into `ModelLimitsSection`'s `rows` prop, joined with model or application
+ * identity from `deploymentItems`. Rows are included only when any displayed period stat has nonzero
+ * usage (Cost stats only, for an application). Order follows `Object.keys(deployments)` —
+ * `deploymentItems` is enrichment-only.
+ *
+ * @param resolveIconUrl - Resolves a deployment's raw `iconUrl` to the URL the avatar should load.
+ * @param resolveDisplayName - Resolves a localized-text map or plain string to the display name for `activeLocale`.
+ */
+export declare const mapUserUsageToModelLimits: (usage: UserLimitStatsResponseDto | undefined, deploymentItems: DeploymentItemDto[], activeLocale: string, t: Translate_2, resolveIconUrl: ResolveIconUrl, resolveDisplayName: ResolveDisplayName) => ModelLimitRow[];
+
 /** Content payload for Markdown file attachments. */
 declare interface MarkdownCanvasContent {
     /** Discriminates the content type to select the correct renderer. */
@@ -2189,6 +2497,8 @@ declare type McpAppDisplayMode = NonNullable<McpUiHostContext['displayMode']>;
 declare interface McpAppHostAdapter {
     /** `McpUiHostContext` to deliver to the mounted app's `ui/initialize` handshake. */
     hostContext: McpUiHostContext;
+    /** Host identity (`name`/`version`) to deliver to the mounted app's `ui/initialize` handshake. */
+    hostInfo: Implementation;
     /** Operator-configured MCP Apps sandbox-proxy URL, or `null` when unconfigured. */
     sandboxUrl: string | null;
     /** Fetches the matched tool's MCP Apps `ui://` resource. */
@@ -2205,7 +2515,7 @@ export declare interface McpAppHostContextParams {
     mcpAppTheme?: string;
     /** Host's current i18n locale (BCP 47). */
     locale: string;
-    /** Operator-configured MCP App user-agent override. Defaults to `'ai-dial-chat'`. */
+    /** Operator-configured MCP App user-agent override. Defaults to the browser's own `navigator.userAgent`. */
     mcpAppUserAgent?: string;
     /**
      * Display modes the host can switch an app between via
@@ -2327,6 +2637,31 @@ export declare enum McpResourceKind {
 
 export declare const mergeCreatedFolderIntoCache: (cache: Map<string, ListFilesItemDto[]>, parentApiPath: string, created: CreateFolderResponseDto, inheritedPermissions?: string[]) => Map<string, ListFilesItemDto[]>;
 
+/**
+ * Merges a freshly-fetched page 0 into the currently-loaded run list: an
+ * already-known id is replaced in place at its existing array position, an
+ * unseen id is prepended (upstream order is `created_at desc`, so it is the
+ * newest), and an id absent from `incoming` is left untouched — a background
+ * refresh never removes a loaded run.
+ */
+export declare const mergeRunsById: (current: ScheduledTaskRunDto[], incoming: ScheduledTaskRunDto[]) => ScheduledTaskRunDto[];
+
+/**
+ * Merges incoming stage deltas into an existing stage list, keyed by `index`.
+ *
+ * Partial `name` and `content` strings are concatenated across chunks;
+ * attachments are merged by their own `index` (concatenating partial `title`
+ * and `data`); every other field on the incoming delta overwrites the
+ * accumulated one. A brand-new stage whose first chunk carries `name: null`
+ * is normalized to `''`.
+ *
+ * Exported for hosts that keep a flattened `Stage[]` on the message instead
+ * of `Message.custom_content.stages` and therefore cannot reuse
+ * {@link applyChunkToMessages}. Prefer `useConversationStream` when the host
+ * can delegate the whole stream loop.
+ */
+export declare const mergeStages: (existing: Stage[], incoming: Stage[]) => Stage[];
+
 /** True when `message` is an assistant message carrying at least one stage. */
 export declare const messageHasStages: (message: Message) => boolean;
 
@@ -2336,10 +2671,31 @@ export declare interface MessagePair {
     assistantMessage: Message;
 }
 
+/** A stable snapshot of one eligible native text selection. */
+export declare interface MessageSelectionReplySnapshot {
+    /** Scope that owned the selection when it was captured. */
+    conversationId: string;
+    /** Message text root containing the captured range. */
+    body: HTMLDivElement;
+    /** Captured native range. */
+    range: Range;
+    /** Native selected text preserved for the generated file. */
+    text: string;
+    /** Visible fragment of the selected range. */
+    rect: DOMRect;
+}
+
 /** Formats MIME types as a human-readable, comma-separated list of dotted extensions (or the MIME type itself for wildcards). */
 export declare const mimeTypesToAttachmentExtensionLabels: (types: string[]) => string;
 
-/** Normalizes `*` to the all-files wildcard and drops any value that is not a valid `DialFileAcceptType`. */
+/**
+ * Normalizes `*` to the all-files wildcard, canonicalizes MIME aliases, and drops
+ * any value that is not a valid `DialFileAcceptType`.
+ *
+ * Aliases are resolved because a file picker matches an `accept` entry against its
+ * own MIME table: a declared `text/json` offers no `.json` file, while the
+ * `application/json` it denotes does.
+ */
 export declare const mimeTypesToDialFileAcceptTypes: (types?: string[]) => DialFileAcceptType[] | undefined;
 
 /**
@@ -2367,6 +2723,7 @@ export declare interface ModelCapabilities {
     hasResume?: boolean;
     hasChatCompletion?: boolean;
     hasResponsesApi?: boolean;
+    hasSkills?: boolean;
     reasoningEfforts?: string[];
 }
 
@@ -2406,18 +2763,6 @@ export declare interface ModelSpecification {
     createdAt?: number;
 }
 
-/** Normalized monthly token usage consumed by the conversation input control. */
-export declare interface MonthlyUsageLimit {
-    /** Normalized used-token count. */
-    used: number;
-    /** Configured monthly token limit. */
-    total: number;
-    /** Remaining monthly tokens, clamped to zero. */
-    remaining: number;
-    /** Monthly utilization percentage, clamped to 0–100. */
-    usedPercent: number;
-}
-
 /** Returns a skill relative path's final segment (its display name in the file tree). */
 export declare const nameFromPath: (path: string) => string;
 
@@ -2429,6 +2774,20 @@ export declare const nameFromPath: (path: string) => string;
  */
 export declare const navigateToolsetOAuthPopup: (popup: Window, auth: ToolsetOAuthSettings, toolsetId: string, callbackPath: string, credentialsLevel?: ToolsetCredentialsLevel, resourceKind?: OAuthResourceKind, offlineUsageConsent?: boolean) => ToolsetOAuthInitiationResult;
 
+/**
+ * Encodes a deployment/application id to its single-encoded form regardless
+ * of whether the value it received was already percent-encoded or the raw,
+ * human-readable form — decoding first then re-encoding once is idempotent
+ * either way, since `decodeDeploymentId` on a raw (unencoded) id is a no-op.
+ * Use this instead of `encodeDeploymentId` at a boundary that cannot
+ * guarantee which form it receives, such as a `postMessage` payload from the
+ * settings iframe: calling `encodeDeploymentId` directly on a value the
+ * sender already encoded escapes the existing `%` characters a second time
+ * (`%20` becomes `%2520`), which the backend only ever undoes once and so
+ * 404s on.
+ */
+export declare const normalizeDeploymentId: (id: string) => string;
+
 /**
  * Normalises a stored response-format string to the current enum. Legacy data
  * may contain `'Markdown'` or `'PlainText'` (capital-first) instead of the
@@ -2444,6 +2803,19 @@ export declare const normalizeResponseFormat: (value: string | undefined) => Res
  */
 export declare const normalizeSkillName: (input: string) => string;
 
+/**
+ * Encodes a toolset id to its single-encoded form regardless of whether the
+ * value received it in was already percent-encoded or the raw,
+ * human-readable form — decoding first then re-encoding once is idempotent
+ * either way, since `decodeToolsetId` on a raw (unencoded) id is a no-op.
+ * Use this instead of `encodeToolsetId` at a boundary that cannot guarantee
+ * which form it receives, such as a `postMessage` payload from an embedded
+ * iframe: calling `encodeToolsetId` directly on a value the sender already
+ * encoded escapes the existing `%` characters a second time (`%20` becomes
+ * `%2520`), which the backend only ever undoes once and so 404s on.
+ */
+export declare const normalizeToolsetId: (toolsetId: string) => string;
+
 export declare const normalizeVirtualPath: (value: string) => string;
 
 /** Arguments handed to the host's exchange callback. */
@@ -2509,13 +2881,23 @@ declare interface OoxmlDocxHighlightLocation {
     path: number[];
     /** Inclusive start character offset within the story's matched text. */
     start: number;
-    /** Exclusive end character offset, already converted from the wire's inclusive `end`. */
+    /** Exclusive end character offset — the wire's `end`, already exclusive, copied through unchanged. */
     endExclusive: number;
     /** The cited text, compared against the text resolved over `[start, endExclusive)`. */
     text: string;
 }
 
-/** Supported document formats rendered by the bundled `@silurus/ooxml` runtime. */
+/** A complete table row in the DOCX body, matched by cell text. */
+declare interface OoxmlDocxTableRowLocation {
+    /** Location kind. */
+    kind: OoxmlHighlightKind.DocxTableRow;
+    /** Plain text of each cell, in column order. */
+    cells: string[];
+    /** 1-based matching row in document order. */
+    occurrence: number;
+}
+
+/** Supported document formats rendered by the installed `@silurus/ooxml` runtime. */
 declare enum OoxmlFileType {
     Docx = 'docx',
     Xlsx = 'xlsx',
@@ -2537,6 +2919,10 @@ declare enum OoxmlHighlightKind {
     DocxTextRange = 'docxTextRange',
     /** A character range inside a single PPTX shape on one slide. */
     PptxTextRange = 'pptxTextRange',
+    /** A complete DOCX table row identified by its cell text. */
+    DocxTableRow = 'docxTableRow',
+    /** A complete PPTX table row identified by its cell text on one slide. */
+    PptxTableRow = 'pptxTableRow',
     /** One cell, or a contiguous same-row cell range, on a named XLSX sheet. */
     XlsxCellRange = 'xlsxCellRange',
 }
@@ -2545,6 +2931,8 @@ declare enum OoxmlHighlightKind {
 declare type OoxmlHighlightLocation =
 | OoxmlDocxHighlightLocation
 | OoxmlPptxHighlightLocation
+| OoxmlDocxTableRowLocation
+| OoxmlPptxTableRowLocation
 | OoxmlXlsxHighlightLocation;
 
 /** A cited character range inside a single shape on one PPTX slide. */
@@ -2557,12 +2945,24 @@ declare interface OoxmlPptxHighlightLocation {
     shapeId: string;
     /** Inclusive start character offset within the shape's matched text. */
     start: number;
-    /** Exclusive end character offset, already converted from the wire's inclusive `end`. */
+    /** Exclusive end character offset — the wire's `end`, already exclusive, copied through unchanged. */
     endExclusive: number;
     /** The cited text, compared against the text resolved over `[start, endExclusive)`. */
     text: string;
 }
 
+/** A complete table row on one PPTX slide, matched by cell text. */
+declare interface OoxmlPptxTableRowLocation {
+    /** Location kind. */
+    kind: OoxmlHighlightKind.PptxTableRow;
+    /** Plain text of each cell, in column order. */
+    cells: string[];
+    /** 1-based matching row on the specified slide. */
+    occurrence: number;
+    /** 1-based slide number. */
+    slide: number;
+}
+
 /** A cited cell, or contiguous same-row cell range, on a named XLSX sheet. */
 declare interface OoxmlXlsxHighlightLocation {
     /** Discriminates this location within `OoxmlHighlightLocation`. */
@@ -2725,7 +3125,7 @@ export declare interface PreparedCopyMoveItem<TDto> {
 export declare const prepareDownloadDestination: (filename: string, mimeType?: string) => Promise<DownloadDestination>;
 
 /**
- * Rename-vs-move disambiguation (design.md D3): entries whose parent folder
+ * Rename-vs-move disambiguation (`openspec/changes/archive/2026-07-21-split-use-dial-file-manager/design.md` D3): entries whose parent folder
  * is unchanged become `renameDtos`; entries whose parent folder changed
  * become `preparedMoveItems`.
  */
@@ -2734,6 +3134,15 @@ export declare const prepareMoveRenameItems: (copiedItems: DialCopiedItem[], buc
     preparedMoveItems: PreparedCopyMoveItem<MoveItemDto>[];
 };
 
+/**
+ * Validates form values before creating a request body. Hosts translate the
+ * returned field codes and must not issue a write when `ok` is false.
+ */
+export declare const prepareScheduledTaskCreateBody: (values: ScheduledTaskCreateFormValues, options: ScheduledTaskValidationOptions) => ScheduledTaskPreparationResult<CreateScheduledTaskBodyDto>;
+
+/** Validates form values before preparing an update request body. */
+export declare const prepareScheduledTaskUpdateBody: (values: ScheduledTaskCreateFormValues, options: ScheduledTaskValidationOptions) => ScheduledTaskPreparationResult<UpdateScheduledTaskBodyDto>;
+
 /** Maximum body length accepted by `CreatePromptDto.content`. */
 export declare const PROMPT_CONTENT_MAX_LENGTH = 50000;
 
@@ -2785,7 +3194,11 @@ export declare enum PromptSource {
     Public = "public"
 }
 
-/** DIAL Core bucket holding organisation-wide skills. */
+/**
+ * DIAL Core bucket holding organisation-wide skills.
+ *
+ * @deprecated Use `PUBLIC_BUCKET` from `@epam/ai-dial-chat-shared`.
+ */
 export declare const PUBLIC_SKILL_BUCKET = "public";
 
 /** The DIAL publish API surface produced by {@link createPublishApiClient}. */
@@ -2817,6 +3230,68 @@ export declare interface QuickAppSchemaLike {
     displayName?: string;
 }
 
+/**
+ * One stage as it arrives from the REST API or the SSE stream, before
+ * normalization. Structurally satisfied by the generated `StageDto` and by a
+ * raw stream delta, both of which omit `index`/`name`/`status` on the chunk
+ * that opens a stage.
+ */
+export declare interface RawStage {
+    /** Ordering key. Defaults to `0` when absent. */
+    index?: number | null;
+    /** Stage title. `null` on the chunk that opens the stage. */
+    name?: string | null;
+    /** Terminal state as a raw wire string; anything other than `'completed'`/`'failed'` means still running. */
+    status?: string | null;
+    /** Additional stage text. */
+    content?: string | null;
+    /** Short source/category label shown beside the stage name. */
+    tag?: string | null;
+    /** Files produced or referenced by this stage. */
+    attachments?: RawStageAttachment[] | null;
+    /**
+     * `index` of the parent stage (its array position in a complete unindexed
+     * array). Nullish means top level; `0` is a valid parent.
+     */
+    parent_stage_index?: number | null;
+}
+
+/**
+ * One stage attachment as it arrives from the REST API or the SSE stream,
+ * before normalization: every field is optional and may be `null`.
+ */
+export declare interface RawStageAttachment {
+    /** Zero-based position in the attachment list. */
+    index?: number | null;
+    /** MIME type of the attachment content. */
+    type?: string | null;
+    /** Display name shown in the UI. */
+    title?: string | null;
+    /** Inline base-64 encoded content. */
+    data?: string | null;
+    /** Remote URL pointing to the attachment content. */
+    url?: string | null;
+    /** MIME type of the referenced resource. */
+    reference_type?: string | null;
+    /** URL of an alternate reference resource. */
+    reference_url?: string | null;
+}
+
+/**
+ * Message-like payload carrying stages under either the wire's snake_case
+ * `custom_content` or a host's camelCased `customContent`.
+ */
+export declare interface RawStageSource {
+    /** Custom content as the DIAL wire format spells it. */
+    custom_content?: {
+        stages?: RawStage[] | null;
+    } | null;
+    /** Custom content as a camelCasing host spells it. */
+    customContent?: {
+        stages?: RawStage[] | null;
+    } | null;
+}
+
 /**
  * Reads a skill file response as raw bytes, or `null` when the body is
  * larger than `SKILL_MANIFEST_MAX_BYTES`. The declared `content-length` is
@@ -2827,6 +3302,24 @@ export declare interface QuickAppSchemaLike {
  */
 export declare const readSkillFileBytes: (response: Response) => Promise<Uint8Array | null>;
 
+/**
+ * Reads a skill file response as raw bytes with no size ceiling, for the
+ * supporting-file **preview** path.
+ *
+ * Previews are user-initiated, one file at a time, and a realistic binary
+ * (a PDF, an image) routinely exceeds `SKILL_MANIFEST_MAX_BYTES` — a cap
+ * sized for `SKILL.md` frontmatter, not for binaries — so applying that cap
+ * here rejected virtually every real PDF before it was ever decoded. This
+ * reader therefore never returns `null`: file size is not a failure class on
+ * the preview path.
+ *
+ * `readSkillFileBytes` and `readSkillManifest` keep their
+ * `SKILL_MANIFEST_MAX_BYTES` ceiling, because they feed the manifest parse
+ * and the textual Content-tab read, where an oversized body must never be
+ * decoded into a string.
+ */
+export declare const readSkillFilePreviewBytes: (response: Response) => Promise<Uint8Array>;
+
 /**
  * Reads a skill manifest response as text, or `null` when the body is larger
  * than `SKILL_MANIFEST_MAX_BYTES`. The size is checked before decoding, so an
@@ -2872,6 +3365,23 @@ export declare const referenceAttachmentToPdfCanvasContent: (attachment: Attachm
 /** Name reserved for the hidden marker file used to create empty folders. */
 export declare const RESERVED_MARKER_NAME = ".dial_folder";
 
+/**
+ * One reset time, already parsed and formatted by the host. Declared
+ * structurally here so this library never imports an application type; the
+ * host passes a value that satisfies this shape (e.g. `apps/chat`'s own
+ * `ResetTimeDisplay`).
+ */
+export declare interface ResetTimeDisplay {
+    /** Exclusive end of the period as an epoch ms value, for the host's boundary scheduling. */
+    resetsAtMs: number;
+    /** Machine-readable instant for a `<time dateTime>` attribute. */
+    isoValue: string;
+    /** Visible reset line. */
+    label: string;
+    /** Accessible expansion of the reset line. */
+    ariaLabel: string;
+}
+
 /**
  * Resolves the primary action for a catalog item.
  *
@@ -2891,7 +3401,8 @@ export declare const resolveCatalogPrimaryAction: (item: CatalogItem, fetchPromp
 /** Resolves a syntax-highlighted code canvas content payload from a DisplayAttachment, or `null` if unavailable. */
 export declare const resolveCodeCanvasContent: (attachment: DisplayAttachment, resolvers: AttachmentCanvasUrlResolvers, language?: string) => Promise<CodeCanvasContent | ErrorCanvasContent | null>;
 
-export declare const resolveDeploymentFolder: (deployment: Pick<DeploymentItemDto, "isMy" | "sharedWithMe" | "applicationFolder">, labels: DeploymentFolderLabels) => string[];
+/** Resolves a deployment's display folder, including organization applications without a folder path. */
+export declare const resolveDeploymentFolder: (deployment: Pick<DeploymentItemDto, "isMy" | "sharedWithMe" | "applicationFolder"> & Partial<Pick<DeploymentItemDto, "type">>, labels: DeploymentFolderLabels) => string[];
 
 /**
  * Resolves a DialFile to the bucket-relative API path used by files BFF endpoints.
@@ -2909,6 +3420,9 @@ export declare const resolveDialFileBucketAndPath: (fileId: string) => {
     path: string;
 } | undefined;
 
+/** A callback that resolves a display name from a localized-text value. */
+declare type ResolveDisplayName = (name: string | Record<string, string> | undefined | null, locale: string) => string;
+
 /** Resolves a DIAL Core file id to a downloadable URL. Host-owned — encodes the app's own file-download endpoint. */
 export declare type ResolveDownloadUrl = (fileId: string) => string | undefined;
 
@@ -2927,20 +3441,45 @@ export declare type ResolveDownloadUrl = (fileId: string) => string | undefined;
  */
 export declare const resolveExternalSourceContentType: (contentType: string, url: string) => string;
 
+/**
+ * Builds the grouped payload for an application-scoped visualizer from the
+ * attachments its entry claims, reporting which of them `resolveAbsoluteUrl`
+ * could produce a URL for. Unlike the single-attachment resolver this fetches
+ * nothing: the grouped protocol hands the visualizer URLs and lets it read
+ * them itself, so the URLs must be absolute — a host-relative path would
+ * resolve against the iframe's own origin. Producing one is host knowledge,
+ * which is why it arrives as a callback rather than being built here.
+ */
+export declare const resolveGroupedVisualizerCanvasContent: (attachments: DisplayAttachment[], resolveAbsoluteUrl: (attachment: DisplayAttachment) => string | undefined, entry: ApplicationVisualizer, themeId: string) => GroupedVisualizerResolution;
+
 /**
  * Resolves an HTML canvas content payload from a DisplayAttachment.
- * Fetches and inlines the HTML as `srcdoc` when the attachment has a download URL or inline data.
- * Returns `null` if no source is available, or an `ErrorCanvasContent` on fetch failure.
- * Rejects `srcdoc` payloads larger than 1 MiB to prevent browser truncation.
+ * When the attachment has a download URL, that URL is the primary render
+ * target so the preview loads via `src` and gets its own response-level CSP
+ * instead of inheriting the host document's — no HTML text is fetched up
+ * front; `resolveSourceText` fetches it lazily, only when the "View source"
+ * toggle is used, and rejects if that fetch fails. `isSameOriginUrl` reflects
+ * a real comparison against the embedding document's own origin.
+ * With no download URL (local file or inline data), falls back to `srcdoc`,
+ * rejecting payloads larger than 1 MiB to prevent browser truncation, and
+ * forwards `resolvers.htmlSrcdocHostUrl` so that HTML can still render under
+ * its own response-level CSP.
+ * Returns `null` if no source is available, or an `ErrorCanvasContent` when
+ * that fallback fetch fails.
  */
 export declare const resolveHtmlCanvasContent: (attachment: DisplayAttachment, resolvers: AttachmentCanvasUrlResolvers) => Promise<HtmlCanvasContent | ErrorCanvasContent | null>;
 
+/** A callback that resolves an icon URL from a deployment's raw `iconUrl` field. */
+declare type ResolveIconUrl = (iconUrl: string | undefined) => string | undefined;
+
 /**
  * Resolves an image canvas content payload from a DisplayAttachment without
- * fetching — returns the BFF download URL (or a local/inline blob URL)
- * directly so the browser cache can be shared with the conversation view's
- * `<img>` element. Error detection is delegated to `<img onError>` in the
- * canvas renderer. Returns `null` if no URL source is available.
+ * fetching — returns a local blob URL or the BFF download URL directly so the
+ * browser cache can be shared with the conversation view's `<img>` element.
+ * A local `File` with bytes takes precedence over the DIAL download URL; a
+ * 0-byte `File` (the file-manager placeholder) does not. Error detection is
+ * delegated to `<img onError>` in the canvas renderer. Returns `null` if no
+ * URL source is available.
  */
 export declare const resolveImageCanvasContent: (attachment: DisplayAttachment, resolvers: AttachmentCanvasUrlResolvers) => ImageCanvasContent | null;
 
@@ -2986,6 +3525,9 @@ export declare const resolvePdfCanvasContent: (attachment: DisplayAttachment, re
  */
 export declare const resolveRelativeDialFilePath: (pathOrFileId: string, bucket: string) => string;
 
+/** Returns the section whose root label is the first segment of `virtualPath`, or `undefined` when none matches. */
+export declare const resolveSectionByPath: <TSection extends DialFileManagerSection>(virtualPath: string, sections: readonly TSection[]) => TSection | undefined;
+
 /**
  * Converts an opaque file-listing id into the path expected by the single-file
  * download endpoint. Core may prefix listing paths with the skill path and its
@@ -3005,6 +3547,16 @@ export declare const resolveSkillManifestFileId: (files: SkillMetadataItemDto[],
 /** Resolves a plain-text canvas content payload from a DisplayAttachment, or `null` if unavailable. */
 export declare const resolveTextCanvasContent: (attachment: DisplayAttachment, resolvers: AttachmentCanvasUrlResolvers) => Promise<PlainTextCanvasContent | ErrorCanvasContent | null>;
 
+/**
+ * Resolves which credentials level a toolset's login applies to, per DIAL
+ * Core's public/private toolset convention: a `public`-bucket toolset is
+ * shared credentials-wise at `User` level, while a private/workspace toolset
+ * is scoped at `Global` level. Every surface that drives a toolset login
+ * (the sign-in-interrupt dialog, the QuickApps editor iframe bridge,
+ * `useToolsetLogin`) must resolve the level this way rather than assuming one.
+ */
+export declare const resolveToolsetCredentialsLevel: (toolsetId: string) => ToolsetCredentialsLevel.User | ToolsetCredentialsLevel.Global;
+
 /**
  * Fetches the attachment payload and builds a `VisualizerCanvasContent` for the
  * given registry entry and theme. Returns `null` when the payload cannot be
@@ -3017,6 +3569,11 @@ export declare const resolveTextCanvasContent: (attachment: DisplayAttachment, r
  */
 export declare const resolveVisualizerCanvasContent: (attachment: DisplayAttachment, resolvers: AttachmentCanvasUrlResolvers, entry: CustomVisualizer, themeId: string) => Promise<VisualizerCanvasContent | null>;
 
+/** An application schema with a resolved id, as returned by {@link getRunnerSchemas}. */
+export declare type RunnerSchema<T extends QuickAppSchemaLike> = T & {
+    id: string;
+};
+
 /** Decodes a URI-encoded path segment, returning the original string if decoding fails. */
 export declare const safeDecodeURI: (path: string) => string;
 
@@ -3058,6 +3615,114 @@ export declare type ScheduledTaskDtoMappingResult = {
     reason: UnsupportedTriggerReason;
 };
 
+/** A checked request preparation result that never serializes invalid values. */
+export declare type ScheduledTaskPreparationResult<TBody> = {
+    ok: true;
+    body: TBody;
+} | {
+    ok: false;
+    errors: ScheduledTaskValidationErrors;
+};
+
+export declare interface ScheduledTaskRunsListRequest {
+    scheduleId: string;
+    limit?: number;
+    offset?: number;
+    signal?: AbortSignal;
+}
+
+export declare interface ScheduledTasksApiClient {
+    listScheduledTasks: (request?: ScheduledTasksListRequest) => Promise<ListScheduledTasksResponseDto>;
+    listScheduledTaskRuns: (request: ScheduledTaskRunsListRequest) => Promise<ListScheduledTaskRunsResponseDto>;
+    createScheduledTask: (body: CreateScheduledTaskBodyDto) => Promise<CreatedScheduledTaskDto>;
+    getScheduledTask: (scheduleId: string) => Promise<ScheduledTaskDto>;
+    updateScheduledTask: (scheduleId: string, body: UpdateScheduledTaskBodyDto) => Promise<UpdatedScheduledTaskDto>;
+    pauseScheduledTask: (scheduleId: string) => Promise<ScheduledTaskDto>;
+    resumeScheduledTask: (scheduleId: string) => Promise<ScheduledTaskDto>;
+    deleteScheduledTask: (scheduleId: string) => Promise<void>;
+}
+
+/** Narrow configured generated-client surface required by scheduler hooks. */
+export declare interface ScheduledTasksConfiguredClient {
+    listScheduledTasks: (request: {
+        limit?: number;
+        offset?: number;
+        search?: string;
+        sort?: ListScheduledTasksSortEnum;
+    }, options?: RequestInit) => Promise<ListScheduledTasksResponseDto>;
+    listScheduledTaskRuns: (request: {
+        scheduleId: string;
+        limit?: number;
+        offset?: number;
+    }, options?: RequestInit) => Promise<ListScheduledTaskRunsResponseDto>;
+    createScheduledTask: (request: {
+        createScheduledTaskBodyDto: CreateScheduledTaskBodyDto;
+    }) => Promise<CreatedScheduledTaskDto>;
+    getScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<ScheduledTaskDto>;
+    updateScheduledTask: (request: {
+        scheduleId: string;
+        updateScheduledTaskBodyDto: UpdateScheduledTaskBodyDto;
+    }) => Promise<UpdatedScheduledTaskDto>;
+    pauseScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<ScheduledTaskDto>;
+    resumeScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<ScheduledTaskDto>;
+    deleteScheduledTask: (request: {
+        scheduleId: string;
+    }) => Promise<void>;
+}
+
+/** App-agnostic request options accepted by the scheduler facade. */
+export declare interface ScheduledTasksListRequest {
+    limit?: number;
+    offset?: number;
+    search?: string;
+    sort?: ListScheduledTasksSortEnum;
+    signal?: AbortSignal;
+}
+
+export declare interface ScheduledTaskTriggerDescription {
+    kind: ScheduledTaskTriggerDescriptionKind;
+    time?: string;
+    dayOfWeek?: string;
+    dayOfMonth?: string;
+    intervalMinutes?: number;
+    date?: Date;
+    expression?: string;
+    sourceTimezone: 'utc';
+}
+
+/** Display categories are independent of task editability. */
+export declare enum ScheduledTaskTriggerDescriptionKind {
+    OneTime = "oneTime",
+    Hourly = "hourly",
+    EveryNMinutes = "everyNMinutes",
+    Daily = "daily",
+    Weekly = "weekly",
+    Monthly = "monthly",
+    Custom = "custom",
+    Invalid = "invalid"
+}
+
+export declare interface ScheduledTaskTriggerDescriptionOptions {
+    /** Display timezone; defaults to UTC for backwards compatibility. */
+    timeZone?: string;
+    /** Date whose timezone offset is used. Defaults to now (the existing UTC-storage policy). */
+    referenceDate?: Date;
+}
+
+/**
+ * Picks the auth-status field matching one credentials level out of a
+ * toolset's `authSettings` — DIAL Core reports `userLevelAuthStatus` and
+ * `globalAuthStatus` as independent fields rather than one status keyed by
+ * level.
+ */
+export declare const selectToolsetAuthStatus: (authSettings: Pick<DialToolsetAuthSettingsDto, "userLevelAuthStatus" | "globalAuthStatus"> | undefined, credentialsLevel: ToolsetCredentialsLevel) => string | undefined;
+
 /** Serializes a prompt export envelope into a pretty-printed JSON blob. */
 export declare const serializePromptExport: (envelope: PromptExportFormat) => Blob;
 
@@ -3091,6 +3756,13 @@ export declare const shouldWatchForDisplayNameUpdate: (conversation: Conversatio
  */
 export declare const SKILL_FILE_UPLOAD_MAX_BYTES = 1048576;
 
+/**
+ * Zero-byte object written at `<folder>/.dial_folder` so an otherwise empty
+ * skill folder survives a save — DIAL Core storage has no directory objects,
+ * so a folder only exists as a file's path prefix.
+ */
+export declare const SKILL_FOLDER_MARKER = ".dial_folder";
+
 /**
  * Upper bound on `nextToken` follow-ups per listing, so a pathological bucket
  * cannot spin the client forever.
@@ -3109,6 +3781,9 @@ export declare const SKILL_MANIFEST_FILE = "SKILL.md";
  */
 export declare const SKILL_MANIFEST_MAX_BYTES: number;
 
+/** Length limit of each skill editor text field. */
+export declare const SKILL_TEXT_FIELD_MAX_LENGTHS: Record<SkillTextField, number>;
+
 /**
  * Client-side mirror of the backend's default `SKILL_UPLOAD_MAX_FILES`
  * (`apps/chat-api/src/config/environment.config.ts`), used only for
@@ -3133,6 +3808,28 @@ export declare interface SkillAboutDetails {
     skillPrompt?: string;
 }
 
+/** Semantic classification of an import request failure. */
+export declare enum SkillArchiveImportErrorKind {
+    Validation = "validation",
+    Collision = "collision",
+    RateLimited = "rateLimited",
+    ServiceUnavailable = "serviceUnavailable",
+    Generic = "generic"
+}
+
+/** Phase of a skill-archive import, driving the host's loading/success/error presentation. */
+export declare enum SkillArchiveImportStatus {
+    Idle = "idle",
+    Uploading = "uploading",
+    Success = "success",
+    Error = "error"
+}
+
+/** Reason a selected/dropped file was rejected before any request was made. */
+export declare enum SkillArchiveSelectionRejectionReason {
+    UnsupportedFilename = "unsupportedFilename"
+}
+
 /** Injected API port for skill detail fetching. Mirrors exact server-api wrapper signatures. */
 export declare interface SkillDetailsApi {
     /** Downloads a raw skill file, returning the raw fetch `Response`. */
@@ -3146,6 +3843,12 @@ export declare interface SkillDetailsApi {
         limit?: number;
         recursive?: boolean;
     }, signal?: AbortSignal): Promise<SkillFileListResponseDto>;
+    /**
+     * Fetches a single skill's own authoritative metadata (`author`,
+     * `updatedAt`, and the rest of `SkillMetadataItemDto`) — not the catalog
+     * listing entry, which may be sparse for a shared skill.
+     */
+    getSkillMetadata(bucket: string, path: string, signal?: AbortSignal): Promise<SkillMetadataItemDto>;
 }
 
 /** Already-configured DIAL Core download operations `useSkillEditorLoad` needs. */
@@ -3189,6 +3892,14 @@ export declare interface SkillEditorSubmitClient {
 export declare interface SkillEditorSubmitMessages {
     /** Shown when a required field is empty. */
     required: string;
+    /** Shown when a name, description or instructions value exceeds its length limit, given that limit. */
+    tooLong: (maxLength: number) => string;
+    /**
+     * Shown when the Instructions value opens with its own YAML frontmatter
+     * block — pasting a whole `SKILL.md` in there would otherwise produce a
+     * manifest with two frontmatter blocks.
+     */
+    instructionsFrontmatter: string;
     /** Shown when the normalized skill name fails DIAL's naming rules. */
     nameInvalid: string;
     /** Shown when the skill name already exists (409), or defensively on an unreachable create-mode 412. */
@@ -3323,6 +4034,9 @@ export declare interface SkillFilesPayload {
  */
 export declare const skillFileToAttachment: (node: SkillFileTreeNode, content: SkillFileContent) => Attachment;
 
+/** Returns the folder path a marker path stands for (`docs/.dial_folder` → `docs`). */
+export declare const skillFolderMarkerParent: (markerPath: string) => string;
+
 /** A `SKILL.md` split into its frontmatter fields and its prose body. */
 export declare interface SkillManifestDocument {
     /** `name` frontmatter field, when present and a string. */
@@ -3389,12 +4103,49 @@ export declare enum SkillSource {
     Public = "public"
 }
 
+/** Skill editor text fields with a length limit. */
+export declare type SkillTextField = 'name' | 'description' | 'instructions';
+
 /** Splits a file name into its base and extension, using only the last dot. */
 export declare const splitFileNameExtension: (fileName: string) => {
     base: string;
     extension: string;
 };
 
+/** Per-start options of {@link UseConversationStreamResult.startStream}. */
+export declare interface StartStreamOptions {
+    /**
+     * Treats a `GenerationConflictError` as "this turn is already being
+     * generated" — e.g. a page reloaded before that generation saved its start
+     * state — and joins the running generation instead of showing the conflict
+     * message, which remains the fallback. Only for a start that sends no new
+     * user text; a send the user typed must keep reporting the conflict.
+     */
+    resumeOnConflict?: boolean;
+}
+
+/**
+ * Answers one question: would appending this text after the fence that
+ * `buildSkillManifest` writes produce a *second* frontmatter block?
+ *
+ * That happens when the text's first non-blank line is a bare `---` and some
+ * later line is a bare `---` too — the exact shape of a `SKILL.md` pasted
+ * wholesale into the editor's Instructions field.
+ *
+ * Detection is deliberately structural rather than YAML-based: a pasted block
+ * whose fenced content fails to parse corrupts the stored manifest
+ * identically (and renders as a setext `h2` in the Catalog's Details tab just
+ * the same), so requiring parseable YAML here would let the worst cases
+ * through. Keeping `parseYaml` out also makes this cheap enough to run on
+ * every keystroke.
+ *
+ * A single unclosed fence returns `false`: with no closing fence there is no
+ * second block, matching `FRONTMATTER_PATTERN`'s own requirement. A `---`
+ * appearing later in the body (a horizontal rule, a setext underline) is
+ * likewise not a frontmatter block.
+ */
+export declare const startsWithFrontmatterBlock: (text: string) => boolean;
+
 /** Options accepted by {@link ConversationStreamTransport.streamCompletion}. */
 export declare interface StreamCompletionOptions {
     onChunk: (chunk: StreamChunk) => void;
@@ -3403,6 +4154,29 @@ export declare interface StreamCompletionOptions {
     signal: AbortSignal;
 }
 
+/**
+ * Reported through `onError` when the network connection carrying a
+ * completion stream is lost (a rejected `fetch`, or a read that fails after a
+ * 2xx response) or goes silent past the idle timeout — what a laptop sleep or
+ * a phone lock mid-generation produces. The backend-owned generation may
+ * still be running, so the caller can recover it rather than treat the
+ * response as failed. `cause` holds the original error, when there is one.
+ */
+export declare class StreamInterruptedError extends Error {
+    constructor(cause?: unknown);
+}
+
+/**
+ * Reported through `onError` when DIAL Core itself signals a failure with an
+ * in-band `{ error: { message } }` SSE chunk. Its `message` is upstream text
+ * intended for the user, unlike a transport failure (failed `fetch`, non-OK
+ * status, broken stream), whose message is technical detail. A custom
+ * transport raises this for any user-facing upstream error text.
+ */
+export declare class StreamUpstreamError extends Error {
+    constructor(message: string);
+}
+
 /** Strips leading and trailing slashes from a path segment. */
 export declare const stripSurroundingSlashes: (path: string) => string;
 
@@ -3720,6 +4494,14 @@ export declare const toPublishEntityType: (type: CatalogEntityType) => CatalogPu
  */
 export declare const toPublishRuleDto: (rule: PublicationRule) => PublishRuleDto;
 
+/**
+ * Returns a renderable `Stage` for one raw payload: `index` defaults to `0`,
+ * `name` to `''`, an unrecognized `status` to `null` (still running), and
+ * `content`/`tag`/`attachments`/`parent_stage_index` are passed through when
+ * present (a parent of `0` included).
+ */
+export declare const toStage: (stage: RawStage) => Stage;
+
 /** Request shape the host's selected-deployment recognition call accepts. */
 export declare interface TranscribeWithDeploymentParams {
     audioUrl: string;
@@ -3728,6 +4510,12 @@ export declare interface TranscribeWithDeploymentParams {
     signal: AbortSignal;
 }
 
+/** A translate function compatible with i18next's `TFunction`. */
+declare type Translate = (key: string, options?: Record<string, unknown>) => string;
+
+/** A translate function compatible with i18next's `TFunction`. */
+declare type Translate_2 = (key: string, options?: Record<string, unknown>) => string;
+
 export declare const trimFileNameToByteLimit: (name: string, limit?: number) => string;
 
 /** An error thrown to indicate the caller is unauthenticated. */
@@ -3736,19 +4524,25 @@ export declare interface UnauthorizedErrorLike extends Error {
     readonly url: string;
 }
 
+/** Returns a new set containing every path from each of `pathSets`. */
+export declare const unionPathSets: (pathSets: readonly ReadonlySet<string>[]) => Set<string>;
+
 /** A skill archive unpacked into its manifest text and a relative-path → bytes map of every other entry. */
 export declare interface UnpackedSkillArchive {
     /** The root `SKILL.md` entry's decoded text content. */
     manifestText: string;
-    /** Every non-manifest entry, keyed by relative path. */
+    /** Every non-manifest, non-marker entry, keyed by relative path. */
     files: Map<string, Uint8Array>;
+    /** Folder paths restored from `<folder>/.dial_folder` marker entries. */
+    folders: string[];
 }
 
 /**
  * Unpacks a whole-skill ZIP (as downloaded from `GET /api/v1/skills/download`
  * — DIAL Core's whole-resource `GET` is the one place this contract still
- * uses a ZIP, per design.md) into its manifest text and every other entry's
- * bytes. Throws if the archive has no root `SKILL.md` entry.
+ * uses a ZIP, per `openspec/changes/archive/2026-10-05-persist-skill-empty-folders/design.md`) into its manifest text, every other entry's
+ * bytes, and the folders its empty-folder markers stand for. Throws if the
+ * archive has no root `SKILL.md` entry.
  */
 export declare const unpackSkillArchive: (bytes: Uint8Array) => UnpackedSkillArchive;
 
@@ -3762,7 +4556,7 @@ export declare enum UnsupportedTriggerReason {
     MissingRequiredFields = "missingRequiredFields"
 }
 
-export declare const updateEntry: (prev: FileUploadBatchState | null, index: number, patch: FileUploadStatus | Partial<Pick<FileUploadEntry, "status" | "percent">>) => FileUploadBatchState | null;
+export declare const updateEntry: (prev: FileUploadBatchState | null, id: string, patch: FileUploadStatus | Partial<Pick<FileUploadEntry, "status" | "percent">>) => FileUploadBatchState | null;
 
 /** Max number of files uploaded concurrently within a single upload batch. */
 export declare const UPLOAD_CONCURRENCY = 3;
@@ -3786,6 +4580,66 @@ export declare interface UploadFileWithProgressOptions {
 /** Upload mode passed to `FilesApi.uploadFile`: overwrite an existing file or fail if it already exists. */
 export declare type UploadMode = 'overwrite' | 'create-only';
 
+/**
+ * i18n key strings that the consuming app's translation bundle must define for
+ * `mapUsageDataToDashboard` to produce correctly translated strings. The
+ * values are the default key paths used by AI DIAL Chat.
+ */
+export declare const USAGE_DATA_I18N_KEYS: {
+    /** Title for the current-UTC-day card (e.g. `'Today'`). */
+    readonly todayTitle: "usage.todayTitle";
+    /** Accessible period description for the current-UTC-day card. */
+    readonly todayPeriodDescription: "usage.todayPeriodDescription";
+    /** Title for the current-UTC-week card (e.g. `'This week'`). */
+    readonly thisWeekTitle: "usage.thisWeekTitle";
+    /** Accessible period description for the current-UTC-week card. */
+    readonly thisWeekPeriodDescription: "usage.thisWeekPeriodDescription";
+    /** Title for the current-UTC-month card (e.g. `'This month'`). */
+    readonly thisMonthTitle: "usage.thisMonthTitle";
+    /** Accessible period description for the current-UTC-month card. */
+    readonly thisMonthPeriodDescription: "usage.thisMonthPeriodDescription";
+    /** Aria label when there is no limit. Receives `{ used: string }`. */
+    readonly unlimitedProgressAriaLabel: "usage.unlimitedProgressAriaLabel";
+    /** Aria label for a progress bar with a finite limit. Receives `{ used: string, total: string, percent: number }`. */
+    readonly progressAriaLabel: "usage.progressAriaLabel";
+};
+
+/**
+ * i18n key strings that the consuming app's translation bundle must define for
+ * `mapUserUsageToModelLimits` and `mapOverallCostLimitsToPeriodStatuses` to produce
+ * correctly translated strings. The values are the default key paths used by AI DIAL Chat.
+ */
+export declare const USAGE_MODEL_LIMITS_I18N_KEYS: {
+    /** Period label used in tooltip text. Receives no interpolation. */
+    readonly todayPeriodDescription: "usage.todayPeriodDescription";
+    /** Period label used in tooltip text. Receives no interpolation. */
+    readonly thisWeekPeriodDescription: "usage.thisWeekPeriodDescription";
+    /** Period label used in tooltip text. Receives no interpolation. */
+    readonly thisMonthPeriodDescription: "usage.thisMonthPeriodDescription";
+    /** Tooltip when the overall cost limit is running low. Receives `{ period: string }`. */
+    readonly overallCostLimitRunningLowTooltip: "usage.overallCostLimitRunningLowTooltip";
+    /** Tooltip when the overall cost limit is reached. Receives `{ period: string }`. */
+    readonly overallCostLimitReachedTooltip: "usage.overallCostLimitReachedTooltip";
+    /** Aria label for a metric cell with no data. */
+    readonly unavailableLabel: "usage.unavailableLabel";
+    /** Supporting label when a token limit follows the cost limit. */
+    readonly followsCostLimitLabel: "usage.followsCostLimitLabel";
+    /** Supporting label when there is no per-deployment token limit. */
+    readonly noLimitLabel: "usage.noLimitLabel";
+    /** Aria label when token usage has no limit but follows the cost limit. Receives `{ used: string }`. */
+    readonly followsCostLimitAriaLabel: "usage.followsCostLimitAriaLabel";
+    /** Aria label when there is no limit. Receives `{ used: string }`. */
+    readonly unlimitedProgressAriaLabel: "usage.unlimitedProgressAriaLabel";
+    /** Aria label for a progress bar with a finite limit. Receives `{ used: string, total: string, percent: number }`. */
+    readonly progressAriaLabel: "usage.progressAriaLabel";
+    /** Label for the spent-cost cell. Receives `{ amount: string }`. */
+    readonly spentLabel: "usage.spentLabel";
+    /** Type caption for an application (agent) row. Receives no interpolation. */
+    readonly applicationTypeLabel: "usage.applicationTypeLabel";
+    /** Supporting label on an application row's spent cost. Receives no interpolation. */
+    readonly includesCalledModelsLabel: "usage.includesCalledModelsLabel";
+};
+
 /**
  * Synchronises the active conversation with the conversation list and returns
  * the panel-space id of the active conversation, or `undefined` when none is active.
@@ -3794,7 +4648,8 @@ export declare type UploadMode = 'overwrite' | 'create-only';
  * 1. If the active conversation is not present in the list, requests a
  *    refresh. The list and refresh callback are intentionally excluded from
  *    the dependency array to avoid a refresh-loop on every list update.
- * 2. Marks the active conversation as viewed whenever it or the list changes.
+ * 2. Marks the active conversation as viewed when its matching identity becomes
+ *    available. List refreshes and persistence rollback do not retry the write.
  */
 export declare const useActiveConversationSync: ({ activeConversationId, items, refreshConversations, markConversationViewed, conversationIdsMatch, toPanelConversationId, }: UseActiveConversationSyncParams) => string | undefined;
 
@@ -3820,6 +4675,25 @@ export declare interface UseActiveConversationSyncParams {
     toPanelConversationId: (id: string) => string;
 }
 
+/** Loads fresh service statuses without coupling proactive credentials to a live completion. */
+export declare const useApplicationCredentials: ({ appId, externalServicesClient, offlineCredentialsClient, }: UseApplicationCredentialsParams) => {
+    services: ApplicationExternalServiceDto[];
+    isOfflineConnected: boolean;
+    isLoading: boolean;
+    hasError: boolean;
+    refresh: () => Promise<void>;
+};
+
+/** Configured operations for loading application credential metadata. */
+export declare interface UseApplicationCredentialsParams {
+    /** Application identifier passed through to the configured client. */
+    appId: string;
+    /** Host-configured external-services API. */
+    externalServicesClient: Pick<ExternalServicesApi, 'listExternalServices'>;
+    /** Host-configured offline-credentials API. */
+    offlineCredentialsClient: Pick<OfflineCredentialsApi, 'getOfflineCredentials'>;
+}
+
 /**
  * Generic single-slot pending / loading / error state machine for
  * confirmation dialogs that trigger an async operation.
@@ -3862,8 +4736,8 @@ export declare const useAttachmentUpload: ({ filesApi, bucket, onNetworkError, d
 
 /** Parameters for {@link useAttachmentUpload}. */
 export declare interface UseAttachmentUploadParams {
-    /** Already-configured generated-client instance used to upload the file. */
-    filesApi: Pick<FilesApi, 'uploadFile'>;
+    /** Already-configured client; optional listing skips stored names after a conflict. */
+    filesApi: Pick<FilesApi, 'uploadFile'> & Partial<Pick<FilesApi, 'listFiles'>>;
     /** DIAL Core bucket the file is uploaded into. */
     bucket: string | undefined;
     /** Called with batched filenames after a burst of network-error upload failures. */
@@ -3883,12 +4757,14 @@ export declare interface UseAttachmentUploadResult {
  * MIME types, debouncing a burst of rejected files into a single
  * `onValidationError` call rather than firing one per file.
  */
-export declare const useAttachmentValidation: ({ allowedMimeTypes, onValidationError, debounceMs, }: UseAttachmentValidationParams) => UseAttachmentValidationResult;
+export declare const useAttachmentValidation: ({ allowedMimeTypes, maxFileSizeBytes, onValidationError, debounceMs, }: UseAttachmentValidationParams) => UseAttachmentValidationResult;
 
 /** Parameters for {@link useAttachmentValidation}. */
 export declare interface UseAttachmentValidationParams {
     /** Resolved MIME types currently allowed for attachments. */
     allowedMimeTypes: string[];
+    /** Maximum attachment file size, in bytes. When omitted, no file is rejected for size. */
+    maxFileSizeBytes?: number;
     /** Called with a structured event when a rejected attachment is reported, at most once per debounce window. */
     onValidationError?: (event: AttachmentValidationErrorEvent) => void;
     /** Debounce window, in ms, before firing `onValidationError` for a rejected file. Defaults to `100`. */
@@ -3913,7 +4789,7 @@ export declare interface UseAttachmentValidationResult {
  * item through the endpoint its type owns and refetching/notifying on
  * completion, and building the Create dropdown's options.
  */
-export declare const useCatalogEditNavigation: ({ deployments, isCustomAppsEnabled, isSchemaAppsEnabled, isHideCustomAppCreationEnabled, isToolsetsEnabled, isPromptsEnabled, quickAppSchemaId, urls, onNavigate, deletePrompt, deleteToolset, deleteSkill, deleteApplication, refetchPrompts, refetchToolsets, refetchSkills, refetchDeployments, onDeleteSuccess, labels, onNotify, onSkillUploadClick, }: UseCatalogEditNavigationParams) => UseCatalogEditNavigationResult;
+export declare const useCatalogEditNavigation: ({ deployments, isCustomAppsEnabled, isSchemaAppsEnabled, isHideCustomAppCreationEnabled, isToolsetsEnabled, isPromptsEnabled, schemas, urls, onNavigate, deletePrompt, deleteToolset, deleteSkill, deleteApplication, refetchPrompts, refetchToolsets, refetchSkills, refetchDeployments, onDeleteSuccess, labels, onNotify, onSkillUploadClick, }: UseCatalogEditNavigationParams) => UseCatalogEditNavigationResult;
 
 /** Parameters accepted by {@link useCatalogEditNavigation}. */
 export declare interface UseCatalogEditNavigationParams {
@@ -3923,8 +4799,8 @@ export declare interface UseCatalogEditNavigationParams {
     isHideCustomAppCreationEnabled: boolean;
     isToolsetsEnabled: boolean;
     isPromptsEnabled: boolean;
-    /** The quick-app schema id resolved by `useCatalogItems`, or `undefined` when no quick-app schema exists. */
-    quickAppSchemaId: string | undefined;
+    /** Application type schemas (runners) loaded at startup; each one except the custom-app schema gets its own Create option. */
+    schemas: ApplicationSchemaSummaryDto[];
     /** Already-configured editor-route URL builders. */
     urls: CatalogEditNavigationUrls;
     /** Navigates the host to a URL built by `urls`. */
@@ -3955,7 +4831,10 @@ export declare interface UseCatalogEditNavigationParams {
 export declare interface UseCatalogEditNavigationResult {
     handleEdit: (item: CatalogItem) => void;
     handleDelete: (item: CatalogItem) => Promise<void>;
+    /** The Create dropdown's items: runners and static options sorted together by label, all filtered by `createSearch.value`. */
     createOptions: DropdownItem[];
+    /** The Create menu's search field state, or `undefined` when no runner option is offered. */
+    createSearch: CatalogCreateSearch | undefined;
 }
 
 /**
@@ -4218,7 +5097,8 @@ export declare interface UseConversationHandlersResult {
  * `.dial`/`.zip`, v5 envelope, old- or new-chat origin) once per file, then
  * re-uploads any archive attachments to `uploads/<YYYY-MM>/` —
  * disambiguating a name collision with a ` (n)` suffix instead of rejecting
- * it — rewrites attachment references (and renamed titles), regenerates each
+ * it — rewrites attachment references (and renamed titles), drops any
+ * reference still pointing into another user's bucket, regenerates each
  * conversation's id/path with a fresh UUID (collision-free save, no replace
  * dialog), and persists every conversation through the injected
  * `conversationsApi`. One job per imported file, not per conversation.
@@ -4288,10 +5168,14 @@ export declare interface UseConversationLookupMapsParams {
  * Returns a memoised array whose shape is compatible with the conversation
  * panel's item contract. All app-specific concerns (icon URL resolution,
  * route generation, id normalisation) are injected via resolver callbacks.
+ *
+ * While every input except `items` is unchanged, a DTO that is referentially
+ * the same as in the previous render maps to the same item object, so a list
+ * change (or a navigation that re-derives the list) re-renders only the rows
+ * whose DTO actually changed.
  */
-export declare const useConversationPanelItems: ({ items, deployments, isDeploymentsLoading, toPanelConversationId, resolveIconUrl, resolveIconTooltip, resolveHref, resolveTaskBadge, }: UseConversationPanelItemsParams) => {
-    showTaskBadge?: boolean | undefined;
-    taskBadgeLabel?: string | undefined;
+export declare const useConversationPanelItems: ({ items, deployments, isDeploymentsLoading, toPanelConversationId, resolveIconUrl, resolveIconTooltip, resolveHref, resolveTaskPresentation, }: UseConversationPanelItemsParams) => {
+    leadingIcon?: ReactNode;
     isUnread?: boolean | undefined;
     id: string;
     title: string;
@@ -4327,11 +5211,12 @@ export declare interface UseConversationPanelItemsResolvers {
     /** Resolves the href to navigate to when the conversation row is clicked. */
     resolveHref: (panelConversationId: string) => string;
     /**
-     * Returns badge metadata for a scheduled-task conversation, or `undefined`
-     * when the item should not show a task badge.
+     * Returns the row presentation for a scheduled-task conversation — a
+     * host-rendered leading icon that replaces the deployment avatar, and the
+     * unread flag — or `undefined` for an ordinary conversation.
      */
-    resolveTaskBadge?: (item: ConversationListItemDto) => {
-        label: string;
+    resolveTaskPresentation?: (item: ConversationListItemDto) => {
+        leadingIcon?: ReactNode;
         isUnread: boolean;
     } | undefined;
 }
@@ -4398,7 +5283,7 @@ export declare interface UseConversationSourcesResult {
     uploaded: DisplayAttachment[];
     /** Deduplicated attachments the assistant generated across the conversation. */
     generated: DisplayAttachment[];
-    /** Quotation sources referenced by assistant messages, deduplicated by URL. */
+    /** Quotation sources referenced by assistant messages, deduplicated by URL; PDF sources are qualified with `#page=N`. */
     sources: QuotationSource[];
 }
 
@@ -4410,7 +5295,7 @@ export declare interface UseConversationSourcesResult {
  * `transport`/`generation`/`channel`/`overlay` capabilities rather than any
  * app context or `server-api` import.
  */
-export declare const useConversationStream: ({ conversationId, state: { setConversation, conversationRef }, transport, generation: { startGeneration, completeGeneration }, channel, overlay, onStopError, generationConflictMessage, }: UseConversationStreamParams) => UseConversationStreamResult;
+export declare const useConversationStream: ({ conversationId, state: { setConversation, conversationRef }, transport, generation: { startGeneration, completeGeneration }, channel, overlay, onStopError, generationConflictMessage, generationPersistenceErrorMessage, onStreamError, batchChunksPerFrame, }: UseConversationStreamParams) => UseConversationStreamResult;
 
 /** Parameters for {@link useConversationStream}. */
 export declare interface UseConversationStreamParams {
@@ -4428,17 +5313,39 @@ export declare interface UseConversationStreamParams {
      * {@link DEFAULT_GENERATION_CONFLICT_MESSAGE}.
      */
     generationConflictMessage?: string;
+    /** Host-translated warning shown when the received answer could not be saved. */
+    generationPersistenceErrorMessage?: string;
+    /**
+     * Receives the original error of every failed stream. The hook shows only
+     * host-supplied or upstream-supplied text on the message bubble and hides
+     * transport detail (e.g. `Failed to fetch`), so this is where the host can
+     * still log or report the raw error.
+     */
+    onStreamError?: (error: Error) => void;
+    /**
+     * Coalesces the displayed chunk updates into one `setConversation` per
+     * animation frame. Chunks still reach the per-path buffer immediately, and
+     * any pending update is flushed before completion, error, stop, or a
+     * superseding generation. Defaults to `false` (one update per chunk).
+     */
+    batchChunksPerFrame?: boolean;
 }
 
 /** Return value of {@link useConversationStream}. */
 export declare interface UseConversationStreamResult {
-    startStream: (conversationId: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum) => void;
+    startStream: (conversationId: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum, options?: StartStreamOptions) => void;
     handleStop: () => void;
     resumeIfAwaitingGeneration: (currentConversationId: string, conversation: Conversation) => void;
     /** Restores the accumulated live assistant message when its conversation is loaded again before completion. */
     restoreBufferedGeneration: (currentConversationId: string, conversation: Conversation) => Conversation;
     isStreaming: boolean;
     canStopStreaming: boolean;
+    /** Whether the displayed conversation's terminal read failed. */
+    hasConversationReloadError: boolean;
+    /** Whether a retry of that read is in flight. */
+    isReloadingConversation: boolean;
+    /** Retries the failed read without saving or regenerating the answer. */
+    retryConversationReload: () => Promise<void>;
 }
 
 /**
@@ -4446,14 +5353,14 @@ export declare interface UseConversationStreamResult {
  * tree's expand/collapse state, search, and the shared per-folder cache that
  * `useDialFileUploadBatch`/`useDialFileMutations`/`useDialFileSharing` invalidate
  * through `invalidateFolders`/`bumpRetry` after their own mutations settle
- * (design.md D1) — this hook is the sole owner/writer of that cache.
+ * (`openspec/changes/archive/2026-07-21-split-use-dial-file-manager/design.md` D1) — this hook is the sole owner/writer of that cache.
  *
  * Supports three listing sources via `activeTab`:
  * - my_files: user's own bucket via `DialFilesApi.listFiles`
  * - shared: files shared with the user via `DialFilesApi.listSharedFiles`
  * - organization: public bucket via `DialFilesApi.listPublicFiles`
  */
-export declare const useDialFileListing: ({ filesApi, bucket, rootLabel, activeTab, onNotification, }: UseDialFileListingOptions) => UseDialFileListingResult;
+export declare const useDialFileListing: ({ filesApi, bucket, rootLabel, activeTab, onNotification, isActive, sessionKey, }: UseDialFileListingOptions) => UseDialFileListingResult;
 
 /** Options accepted by `useDialFileListing`. */
 export declare interface UseDialFileListingOptions {
@@ -4467,6 +5374,10 @@ export declare interface UseDialFileListingOptions {
     activeTab: DialFileManagerTabs;
     /** Called with a structured event when a folder-load operation fails. */
     onNotification?: (notification: FileManagerNotification) => void;
+    /** When false, the hook issues no `DialFilesApi` call and reports `isLoading: false`. Defaults to `true`. */
+    isActive?: boolean;
+    /** Changing this value resets cache and navigation exactly like an `activeTab` change. Defaults to `undefined`. */
+    sessionKey?: string;
 }
 
 /** Values returned by `useDialFileListing`. */
@@ -4502,7 +5413,7 @@ export declare interface UseDialFileListingResult {
     /**
      * Deletes the given API-path cache keys so the next listing fetch/expand for
      * that folder re-fetches from the server. The only way sibling sub-hooks may
-     * invalidate the shared cache (design.md D1).
+     * invalidate the shared cache (`openspec/changes/archive/2026-07-21-split-use-dial-file-manager/design.md` D1).
      */
     invalidateFolders: (apiPaths: string[]) => void;
     /** Merges a just-created folder into its parent's cache entry (optimistic display for create-folder). */
@@ -4523,7 +5434,7 @@ export declare interface UseDialFileListingResult {
  * every translated string reaches it through `labels`,
  * `disabledNewButtonTooltip`, and `buildValidationErrorMessage`.
  */
-export declare const useDialFileManager: ({ filesApi, bucket, rootLabel, activeTab, onNotification, onOperationSuccess, forbiddenSymbolsRegExp, variant, actionProfile, labels, locale, disabledNewButtonTooltip, downloadDestination, buildValidationErrorMessage, }: UseDialFileManagerOptions) => UseDialFileManagerResult;
+export declare const useDialFileManager: ({ filesApi, bucket, rootLabel, activeTab, isActive, sessionKey, onNotification, onOperationSuccess, forbiddenSymbolsRegExp, variant, actionProfile, labels, locale, disabledNewButtonTooltip, downloadDestination, buildValidationErrorMessage, }: UseDialFileManagerOptions) => UseDialFileManagerResult;
 
 export declare interface UseDialFileManagerOptions {
     /** Injected operation port used for every file-manager network call. */
@@ -4534,6 +5445,10 @@ export declare interface UseDialFileManagerOptions {
     rootLabel?: string;
     /** Active tab — drives listing source and per-tab options. Defaults to MyFiles. */
     activeTab?: DialFileManagerTabs;
+    /** When false, the listing issues no `DialFilesApi` call and reports `isLoading: false`. Defaults to `true`. */
+    isActive?: boolean;
+    /** Changing this value resets cache and navigation exactly like an `activeTab` change. Defaults to `undefined`. */
+    sessionKey?: string;
     /** Called when a file-manager action should surface a toast notification. */
     onNotification?: (notification: FileManagerNotification) => void;
     /** Called when a mutation succeeds, instead of invoking an application notification service directly. */
@@ -4588,7 +5503,7 @@ export declare interface UseDialFileManagerResult {
     onSearchFiles: (folder: string, query: string) => void;
     /** Search: true while a search request is in flight. */
     isSearching: boolean;
-    /** Search: flat list of matching files, or null when search is not active. */
+    /** Search: flat, unfiltered recursive listing of the current folder, or null when search is not active. */
     searchResults: DialFile[] | null;
     /** Search: clears results and exits search mode. */
     clearSearchResults: () => void;
@@ -4612,7 +5527,9 @@ export declare interface UseDialFileManagerResult {
     uploadBatchState: FileUploadBatchState | null;
     /** Upload: abort all in-flight and queued uploads. */
     cancelUpload: () => void;
-    /** Upload: dismiss the progress modal after the batch has settled. */
+    /** Upload: abort one queued or in-flight upload by its entry id. */
+    cancelUploadFile: (id: string) => void;
+    /** Upload: empty the upload queue. */
     clearUploadBatch: () => void;
     /** Folder creation: called when user confirms a new folder name. */
     onCreateFolder: (file: DialUploadFileItem, folderPath: string, fileId: string) => Promise<void>;
@@ -4679,7 +5596,7 @@ export declare interface UseDialFileManagerResult {
     /**
      * True while any mutating file-manager operation is in flight: the OR of
      * `isCreatingFolder`, `isDownloading`, `isDeleting`, `isRenaming`, `isCopying`,
-     * `isMoving`, `isUnsharing`, `isRemovingAccess`, and `uploadBatchState != null`.
+     * `isMoving`, `isUnsharing`, `isRemovingAccess`, and any upload still queued or running.
      *
      * Deliberately excludes three flags, each already fully contained by its own
      * scoped loading UI:
@@ -4690,17 +5607,42 @@ export declare interface UseDialFileManagerResult {
     isAnyOperationInProgress: boolean;
 }
 
+/**
+ * Composes one `useDialFileManager` per source tab (My files, Shared,
+ * Organization) so the File storage page can offer an All tab without a
+ * second copy of the per-tab rules. On a single tab it returns that section's
+ * result; on All it merges the section roots into one tree and routes every
+ * callback to the section owning the path. Section availability and names
+ * arrive through `sections` — the hook reads no config, i18n, or context.
+ */
+export declare const useDialFileManagerSections: ({ activeTab, sections, ...managerOptions }: UseDialFileManagerSectionsOptions) => UseDialFileManagerSectionsResult;
+
+/** Options accepted by `useDialFileManagerSections`. */
+export declare interface UseDialFileManagerSectionsOptions extends Omit<UseDialFileManagerOptions, 'activeTab' | 'rootLabel' | 'isActive' | 'sessionKey'> {
+    /** Active tab, including `DialFileManagerTabs.All`. */
+    activeTab: DialFileManagerTabs;
+    /** Enabled source tabs in display order, each with its translated top-level folder name. */
+    sections: DialFileManagerSection[];
+}
+
+/** Values returned by `useDialFileManagerSections`. */
+export declare interface UseDialFileManagerSectionsResult extends UseDialFileManagerResult {
+    /** Source tab of the browsed folder; never `DialFileManagerTabs.All`. */
+    sectionTab: DialFileManagerTabs;
+}
+
 /**
  * Filters the file-manager's tab list down to the host's configured set and
  * resets `activeTab` to the highest-priority still-enabled tab when the
  * current one becomes excluded. A `fileManagerTabs` of `undefined` means no
  * restriction — every tab in `allTabs` stays enabled and no reset ever fires.
+ * The All tab is kept only while at least two source tabs are enabled.
  */
-export declare const useDialFileManagerTabConfig: (activeTab: DialFileManagerTabs, onTabChange: (tab: DialFileManagerTabs) => void, allTabs: TabModel[] | undefined, fileManagerTabs: string[] | undefined) => UseDialFileManagerTabConfigResult;
+export declare const useDialFileManagerTabConfig: (activeTab: DialFileManagerTabs, onTabChange: (tab: DialFileManagerTabs) => void, allTabs: FilterChipItem<DialFileManagerTabs>[] | undefined, fileManagerTabs: string[] | undefined) => UseDialFileManagerTabConfigResult;
 
 /** Values returned by `useDialFileManagerTabConfig`. */
 export declare interface UseDialFileManagerTabConfigResult {
-    tabs: ToolbarOptions['tabs'];
+    tabs: FileTreeOptions['tabs'];
 }
 
 /**
@@ -4825,10 +5767,11 @@ export declare interface UseDialFileSharingResult {
 
 /**
  * Manages upload batches (single-file and ZIP-archive extraction), including
- * concurrency-limited progress tracking and abort. Invalidates the shared
- * listing cache for the destination folder through `invalidateFolders`/
- * `bumpRetry` after a batch settles — it never holds its own copy of the
- * cache.
+ * concurrency-limited progress tracking and per-file abort. A batch started
+ * while another is on screen is appended to it, and settled entries stay in
+ * `uploadBatchState` until `clearUploadBatch`. Invalidates the shared listing
+ * cache for the destination folder through `invalidateFolders`/`bumpRetry`
+ * after a batch settles — it never holds its own copy of the cache.
  */
 export declare const useDialFileUploadBatch: ({ filesApi, bucket, rootLabel, activeTab, cache, sharedRootMetaRef, invalidateFolders, bumpRetry, onNotification, }: UseDialFileUploadBatchOptions) => UseDialFileUploadBatchResult;
 
@@ -4861,6 +5804,7 @@ export declare interface UseDialFileUploadBatchResult {
     onValidateUpload: (files: DialUploadFileItem[], existingFiles: DialFile[], destinationFolder: string) => Promise<FileUploadValidationResult>;
     uploadBatchState: FileUploadBatchState | null;
     cancelUpload: () => void;
+    cancelUploadFile: (id: string) => void;
     clearUploadBatch: () => void;
 }
 
@@ -4889,6 +5833,64 @@ export declare interface UseFavoriteEntitiesStateResult {
     toggleFavorite: (id: string, isFavorite: boolean, entityType?: FavoriteEntityType) => Promise<void>;
 }
 
+/**
+ * Composes the file-manager tab/listing hooks into the stateful part of an attachment picker:
+ * active tab, selected paths, and hidden-path/MIME/size/folder row eligibility. Returns the
+ * existing `useDialFileManager` controller unchanged and the selection/tab/eligibility fields
+ * `FileManagerAttachModal` already consumes — it composes that modal, it does not replace it.
+ * Final attachment filtering, deduplication, and count enforcement stay owned by the modal.
+ */
+export declare const useFileAttachmentPicker: ({ fileManagerOptions, bucket, forbiddenSymbolsRegExp, tabLabels, allowedTabs, initialTab, allowedTypes, maxSelectableFileSize, canAttachFolders, }: UseFileAttachmentPickerOptions) => UseFileAttachmentPickerResult;
+
+/** Options accepted by {@link useFileAttachmentPicker}. */
+export declare interface UseFileAttachmentPickerOptions {
+    /**
+     * Configured `useDialFileManager` options besides the values this hook derives:
+     * `bucket`, `activeTab`, `rootLabel`, `variant`, and `forbiddenSymbolsRegExp`.
+     */
+    fileManagerOptions: Omit<UseDialFileManagerOptions, 'bucket' | 'activeTab' | 'rootLabel' | 'variant' | 'forbiddenSymbolsRegExp'>;
+    /** DIAL Core bucket to browse. */
+    bucket: string;
+    /** Regexp of characters forbidden in file/folder names, forwarded to `useDialFileManager`. */
+    forbiddenSymbolsRegExp?: RegExp;
+    /** Host-translated label per tab; also supplies the active tab's root-folder label. */
+    tabLabels: Record<DialFileManagerTabs, string>;
+    /** Tab ids the host's configuration allows. `undefined` allows every tab. */
+    allowedTabs?: string[];
+    /** Initial active tab. Defaults to `DialFileManagerTabs.MyFiles`. */
+    initialTab?: DialFileManagerTabs;
+    /** MIME types eligible for selection/upload. Empty or absent allows every type. */
+    allowedTypes?: string[];
+    /** Files at or below this size (bytes) remain eligible; absent allows any size. */
+    maxSelectableFileSize?: number;
+    /** Whether folder rows are eligible for selection. Defaults to `false`. */
+    canAttachFolders?: boolean;
+}
+
+/** Result returned by {@link useFileAttachmentPicker}. */
+export declare interface UseFileAttachmentPickerResult {
+    /** The composed file-manager controller; forward to `FileManagerAttachModal`'s `controller` prop. */
+    controller: UseDialFileManagerResult;
+    /** Active tab. */
+    activeTab: DialFileManagerTabs;
+    /** Tab list filtered to `allowedTabs`; forward to `FileManagerAttachModal`'s `tabs` prop. */
+    tabs: FileTreeOptions['tabs'];
+    /** Switches the active tab and clears the current selection. */
+    onTabChange: (tab: DialFileManagerTabs) => void;
+    /** Currently selected paths. */
+    selectedPaths: Set<string>;
+    /** Replaces the selection with a defensive copy of the given set. */
+    onSelectedPathsChange: (paths: Set<string>) => void;
+    /** Row eligibility predicate; forward to `FileManagerAttachModal`'s `isRowSelectable` prop. */
+    isRowSelectable: (node: {
+        data?: FileManagerSelectableNode | null;
+    }) => boolean;
+    /** MIME eligibility predicate; forward to `FileManagerAttachModal`'s `isFileTypeAllowed` prop. */
+    isFileTypeAllowed: (contentType: string) => boolean;
+    /** Accepted upload MIME types; forward to `FileManagerAttachModal`'s `allowedFileTypes` prop. */
+    allowedFileTypes: DialFileAcceptType[] | undefined;
+}
+
 export { useGridEditingScroll }
 
 export { UseGridEditingScrollOptions }
@@ -4932,10 +5934,11 @@ export declare interface UseImportFilePickerResult {
  * Builds the `McpAppHostAdapter` a host injects into `@epam/ai-dial-mcp-apps`'s
  * hooks/components, wiring the library's host-context/tool-call/resource-fetch
  * contract to a configured `McpAppsApiClient` and this app's theme/locale/config
- * values (`hostContextParams`, `sandboxUrl`) — this hook itself never reads app
- * context, so a host builds those values wherever it already has them.
+ * values (`hostContextParams`, `sandboxUrl`), plus the host's own identity
+ * (`hostInfo`) — this hook itself never reads app context, so a host builds
+ * those values wherever it already has them.
  */
-export declare const useMcpAppHostAdapter: (displayMode: "inline" | "fullscreen", client: McpAppsApiClient, sandboxUrl: string | null, hostContextParams: McpAppHostContextParams) => McpAppHostAdapter;
+export declare const useMcpAppHostAdapter: (displayMode: "inline" | "fullscreen", client: McpAppsApiClient, sandboxUrl: string | null, hostContextParams: McpAppHostContextParams, hostInfo: Implementation) => McpAppHostAdapter;
 
 /**
  * Builds the `McpUiHostContext` delivered to a mounted MCP App during its
@@ -4965,6 +5968,35 @@ export declare const useMcpAppHostContext: (displayMode: "inline" | "fullscreen"
  */
 export declare const useMcpAppTools: (client: McpAppsApiClient, deployment: DeploymentItemDto | undefined, messages: Message[], toolsets: DialToolsetDto[]) => McpAppToolRef[];
 
+/**
+ * Captures eligible message text and creates Reply files for an existing composer
+ * attachment flow without acquiring host deployment, upload or localization knowledge.
+ */
+export declare const useMessageSelectionReply: ({ conversationId, enabled, droppedFiles, onDroppedFilesConsumed, }: UseMessageSelectionReplyParams) => {
+    contentRef: (node: HTMLDivElement | null) => (() => void) | undefined;
+    actionRef: RefObject<HTMLDivElement | null>;
+    selection: MessageSelectionReplySnapshot | null;
+    onReply: () => void;
+    dismiss: () => void;
+    pendingFiles: File[];
+    onFilesConsumed: () => void;
+    focusRequestId: number | undefined;
+    onAttachmentsChange: (attachments: Attachment[]) => void;
+    addedRevision: number;
+};
+
+/** Parameters accepted by {@link useMessageSelectionReply}. */
+export declare interface UseMessageSelectionReplyParams {
+    /** Identifier used to discard selection and queued files after a scope change. */
+    conversationId: string;
+    /** Whether the host currently permits a Reply attachment. */
+    enabled: boolean;
+    /** Files from the host's ordinary page-drop queue. */
+    droppedFiles: File[];
+    /** Acknowledges the captured page-drop batch after the composer accepts it. */
+    onDroppedFilesConsumed: () => void;
+}
+
 /**
  * Completes an OAuth authorization-code flow from inside the callback popup:
  * reads and clears the redirect state written into this popup's own
@@ -5038,8 +6070,6 @@ export declare const useOpenMcpAppCanvas: (cache: McpAppResponseCache, hostAdapt
 
 /** User-facing text `useOpenMcpAppCanvas` needs but cannot resolve itself — a lib must not call `t()`. */
 export declare interface UseOpenMcpAppCanvasLabels {
-    /** Canvas panel title while an MCP App is loading or open. */
-    title: string;
     /** Error label shown when the resource fetch is forbidden (HTTP 403). */
     forbiddenErrorLabel: string;
     /** Error label shown for any other resource-load/tool-call failure. */
@@ -5168,15 +6198,65 @@ export declare interface UsePublishFoldersResult {
      */
     onCreatePublishFolder: (parentPath: string[], name: string) => Promise<void>;
     /**
-     * Records `folderPath` as a publish destination the user has actually used,
-     * so it keeps appearing in the tree on later publishes. Call it after a
-     * successful publish.
+     * Records `folderPath` as the most recent publish destination (moving it to
+     * the front if already remembered), so it keeps appearing in the tree on
+     * later publishes. Call it after a successful publish.
      */
     rememberPublishFolder: (folderPath: string[]) => void;
     /** Heuristic write-access check for a folder path (see the TODO above). */
     hasPublishWriteAccess: (folderPath: string[]) => boolean;
 }
 
+/** Shared, cancellation-safe pagination and background refresh for one schedule's run history. */
+export declare const useScheduledTaskRuns: (client: ScheduledTasksApiClient, { scheduleId, enabled, pageSize, nextRunTime, }: UseScheduledTaskRunsOptions) => {
+    items: ScheduledTaskRunDto[];
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    initialError: Error | null;
+    loadMoreError: Error | null;
+    hasMore: boolean;
+    loadMore: () => void;
+    retryLoadMore: () => void;
+    refetch: () => void;
+};
+
+export declare interface UseScheduledTaskRunsOptions {
+    scheduleId: string;
+    enabled?: boolean;
+    pageSize?: number;
+    /**
+     * The task's next scheduled run time (ISO string), when known. Drives the
+     * one-shot background refresh described on {@link useScheduledTaskRuns}.
+     * The caller already holds the task DTO — this hook never fetches it.
+     */
+    nextRunTime?: string | null;
+}
+
+/** Shared scheduler-list lifecycle with generation-scoped stale-response guards. */
+export declare const useScheduledTasks: (client: ScheduledTasksApiClient, { enabled, pageSize, debounceMs, initialSearch, initialSort, }?: UseScheduledTasksOptions) => {
+    items: ScheduledTaskDto[];
+    searchQuery: string;
+    setSearchQuery: Dispatch<SetStateAction<string>>;
+    sortKey: "firstToRun" | "lastToRun" | "newest" | "nameAZ";
+    setSortKey: Dispatch<SetStateAction<"firstToRun" | "lastToRun" | "newest" | "nameAZ">>;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    initialError: Error | null;
+    loadMoreError: Error | null;
+    hasMore: boolean;
+    loadMore: () => void;
+    retryLoadMore: () => void;
+    refetch: () => void;
+};
+
+export declare interface UseScheduledTasksOptions {
+    enabled?: boolean;
+    pageSize?: number;
+    debounceMs?: number;
+    initialSearch?: string;
+    initialSort?: ListScheduledTasksSortEnum;
+}
+
 /**
  * Resolves and manages share-link data for a DIAL Core resource.
  *
@@ -5217,6 +6297,48 @@ export declare interface UseShareRecipientsCountResult {
     invalidateRecipientsCount: (itemId: string) => void;
 }
 
+/**
+ * Headless controller for the skill-archive upload flow: dialog visibility, the exact-filename
+ * precheck, in-flight exclusion, abort-on-close, and import completion. The host supplies the configured request
+ * and observes completion/failure through the injected callbacks; the hook never imports app
+ * contexts, i18n, or a configured API client.
+ */
+export declare const useSkillArchiveImport: <TResult>({ importArchive, onImported, onError, manifestFileName, }: UseSkillArchiveImportOptions<TResult>) => UseSkillArchiveImportResult;
+
+/** Options accepted by {@link useSkillArchiveImport}. */
+export declare interface UseSkillArchiveImportOptions<TResult> {
+    /** Submits the selected archive; the host owns the client. `signal` aborts when the dialog closes or the hook unmounts mid-upload. */
+    importArchive: (file: File, signal: AbortSignal) => Promise<TResult>;
+    /** Called once after a successful import (and any awaited host follow-up) settles. */
+    onImported: (result: TResult) => void | Promise<void>;
+    /** Called once when the import request, or the host's follow-up in {@link onImported}, fails. */
+    onError: (error: unknown, kind: SkillArchiveImportErrorKind) => void;
+    /** Exact filename treated as the skill manifest. Defaults to `'SKILL.md'`. */
+    manifestFileName?: string;
+}
+
+/** Result returned by {@link useSkillArchiveImport}. */
+export declare interface UseSkillArchiveImportResult {
+    /** Whether the upload dialog is open. */
+    isDialogOpen: boolean;
+    /** Current phase of the import. */
+    status: SkillArchiveImportStatus;
+    /** Whether an import request is in flight; the dialog stays open until it succeeds. */
+    isUploading: boolean;
+    /** Reason the current/last selection was rejected locally; `undefined` once cleared. */
+    selectionRejectionReason: SkillArchiveSelectionRejectionReason | undefined;
+    /** Classified failure of the last import request; `undefined` outside a request failure. */
+    errorKind: SkillArchiveImportErrorKind | undefined;
+    /** Opens the dialog and clears any previous rejection or request failure. */
+    openDialog: () => void;
+    /** Closes the dialog, aborting an in-flight import, and clears any rejection reason. */
+    closeDialog: () => void;
+    /** Wire to the dialog drop zone's `onChange`. */
+    handleFilesSelected: (files: File[]) => void;
+    /** Wire to the dialog drop zone's `onReject`. */
+    handleFilesRejected: () => void;
+}
+
 /**
  * Headless data pipeline behind a skill details side panel: resolves the
  * selected skill from the listings, maps it to a catalog item with its
@@ -5318,7 +6440,7 @@ export declare interface UseSkillEditorLoadResult {
  * `client.createSkill`/`client.updateSkill`, and mapping the resulting
  * success/error/conflict outcomes to presentable state.
  */
-export declare const useSkillEditorSubmit: ({ bucket, isEditMode, files, filesContentRef, frontmatterRef, loadedPathRef, etagRef, returnUrl, refetchSkills, client, messages, onNavigate, onNotify, }: UseSkillEditorSubmitParams) => UseSkillEditorSubmitResult;
+export declare const useSkillEditorSubmit: ({ bucket, isEditMode, files, filesContentRef, frontmatterRef, loadedPathRef, etagRef, returnUrl, getCreateReturnUrl, refetchSkills, client, messages, onNavigate, onNotify, }: UseSkillEditorSubmitParams) => UseSkillEditorSubmitResult;
 
 /** Parameters accepted by {@link useSkillEditorSubmit}. */
 export declare interface UseSkillEditorSubmitParams {
@@ -5338,6 +6460,8 @@ export declare interface UseSkillEditorSubmitParams {
     etagRef: React.MutableRefObject<string | undefined>;
     /** Where to navigate on a successful save. */
     returnUrl: string;
+    /** Resolves the destination after creation from the normalized skill path. Defaults to `returnUrl`. */
+    getCreateReturnUrl?: (path: string) => string;
     /** Refetches the host's skill listing after a successful save. */
     refetchSkills: () => Promise<void>;
     /** Already-configured create/update operations. */
@@ -5358,6 +6482,10 @@ export declare interface UseSkillEditorSubmitResult {
     errors: SkillEditorErrors;
     /** General submit-time error, distinct from a stale-edit `conflict`. */
     submitError: string | undefined;
+    /** Whether `submitError` was caused by something a plain re-send can clear, rather than by the submission itself. */
+    isSubmitErrorRetryable: boolean;
+    /** Re-submits the values of the attempt that produced `submitError`. No-op before the first submit. */
+    retrySubmit: () => void;
     /** Present when the last save hit a stale-ETag conflict. */
     conflict: {
         message: string;
@@ -5366,15 +6494,22 @@ export declare interface UseSkillEditorSubmitResult {
     clearConflict: () => void;
     /** Validates and submits the given form values. */
     handleSubmit: (values: SkillEditorValues) => Promise<void>;
+    /**
+     * Re-runs the Instructions frontmatter check against the editor's current
+     * values, so a pasted `SKILL.md` is flagged as the text lands rather than
+     * only on submit. Pass as the editor's `onValuesChange`.
+     */
+    handleValuesChange: (values: SkillEditorValues) => void;
 }
 
 /**
  * Owns the Skill Editor's batch file upload workflow: validating a staged
  * batch, committing it atomically (supporting files plus an optional
- * `SKILL.md` manifest import, with a confirmation gate), and removing
+ * `SKILL.md` manifest import, with a confirmation gate), creating empty
+ * folders, expanding `.zip` archives for staging, and removing
  * already-committed nodes.
  */
-export declare const useSkillFileActions: ({ files, setFiles, filesContentRef, frontmatterRef, loadedValues, setLoadedValues, isEditMode, isDirty, setSelectedPath, messages, }: UseSkillFileActionsParams) => UseSkillFileActionsResult;
+export declare const useSkillFileActions: ({ files, setFiles, filesContentRef, frontmatterRef, loadedValues, setLoadedValues, isEditMode, isDirty, setSelectedPath, messages, pickFromFileSystem, }: UseSkillFileActionsParams) => UseSkillFileActionsResult;
 
 /** Parameters accepted by {@link useSkillFileActions}. */
 export declare interface UseSkillFileActionsParams {
@@ -5398,6 +6533,12 @@ export declare interface UseSkillFileActionsParams {
     setSelectedPath: Dispatch<SetStateAction<string>>;
     /** Localized messages, resolved by the host. */
     messages: SkillFileActionsMessages;
+    /**
+     * Opens the host's file-system picker; passed through unchanged as
+     * `fileActions.pickFromFileSystem`. Omit to hide the editor's "Open DIAL
+     * file system" entry.
+     */
+    pickFromFileSystem?: () => Promise<SkillFileSourceEntry[] | undefined>;
 }
 
 /** Return value of {@link useSkillFileActions}. */
@@ -5444,10 +6585,11 @@ export declare interface UseSkillFilePreviewResult {
 
 /**
  * Headless hook that encapsulates skill detail fetching: manifest download and
- * parse, package file listing, overview construction, and in-package file
- * loads. `useCatalogItemDetails` delegates its skill branch here; hosts that
- * only surface skill details consume this hook directly, without the
- * deployment and prompt ports the full catalog pipeline requires.
+ * parse, package file listing, authoritative metadata fetching, overview
+ * construction, and in-package file loads. `useCatalogItemDetails` delegates
+ * its skill branch here; hosts that only surface skill details consume this
+ * hook directly, without the deployment and prompt ports the full catalog
+ * pipeline requires.
  */
 export declare const useSkillItemDetails: ({ api, skills, skillOverviewLabels, }: UseSkillItemDetailsOptions) => UseSkillItemDetailsResult;
 
@@ -5728,4 +6870,7 @@ export declare enum WithLogin {
     WithConfig = "with-config"
 }
 
+/** Returns `sections` with every root label usable as a unique first path segment, falling back to the tab id. */
+export declare const withRoutableRootLabels: <TSection extends DialFileManagerSection>(sections: readonly TSection[]) => TSection[];
+
 export { }