@epam/ai-dial-chat-hooks 1.1.0-dev.383 → 1.1.0-dev.390

package/catalog.d.ts

@@ -0,0 +1,946 @@
+import { CatalogContentTreeNode } 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';
+import { CatalogItemCredentials } from '@epam/ai-dial-catalog';
+import { CatalogItemDetailsFetchResult } from '@epam/ai-dial-catalog';
+import { CatalogItemLimits } from '@epam/ai-dial-catalog';
+import { CatalogItemOverview } from '@epam/ai-dial-catalog';
+import { CatalogItemTabData } from '@epam/ai-dial-catalog';
+import { DeploymentDetailsDto } from '@epam/ai-dial-chat-api-client';
+import { DeploymentItemDto } from '@epam/ai-dial-chat-api-client';
+import { DeploymentLimitsResponseDto } from '@epam/ai-dial-chat-api-client';
+import { DialToolsetAuthSettingsDto } from '@epam/ai-dial-chat-api-client';
+import { DialToolsetDto } from '@epam/ai-dial-chat-api-client';
+import { ListFilesResponseDto } from '@epam/ai-dial-chat-api-client';
+import { PromptResponseDto } from '@epam/ai-dial-chat-api-client';
+import { PublicationRule } from '@epam/ai-dial-publish-panel';
+import { PublishApi } from '@epam/ai-dial-chat-api-client';
+import { PublishCatalogEntityDto } from '@epam/ai-dial-chat-api-client';
+import { PublishConversationResultDto } from '@epam/ai-dial-chat-api-client';
+import { PublishFolderNode } from '@epam/ai-dial-publish-panel';
+import { PublishHistoryEntry } from '@epam/ai-dial-publish-panel';
+import { PublishHistoryEntryDto } from '@epam/ai-dial-chat-api-client';
+import { PublishResultDto } from '@epam/ai-dial-chat-api-client';
+import { PublishRuleDto } from '@epam/ai-dial-chat-api-client';
+import { SkillFileListResponseDto } from '@epam/ai-dial-chat-api-client';
+import { SkillMetadataItemDto } 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';
+
+/** Feature-support flags for an agent (application) deployment. */
+export declare interface AgentCapabilities {
+    hasTools?: boolean;
+    hasMcp?: boolean;
+    hasCaching?: boolean;
+    hasParallelToolCalls?: boolean;
+    hasUrlAttachments?: boolean;
+    hasFolderAttachments?: boolean;
+    hasSeed?: boolean;
+    hasSystemPrompt?: boolean;
+    hasResume?: boolean;
+    hasConfiguration?: boolean;
+    hasChatCompletion?: boolean;
+    hasResponsesApi?: boolean;
+}
+
+/** Input-attachment configuration for an agent (application) deployment. */
+export declare interface AgentConfiguration {
+    inputAttachmentTypes?: string[];
+}
+
+/** Full details payload for an agent (application)-type deployment. */
+export declare interface AgentEntityDetails {
+    specification?: AgentSpecification;
+    configuration?: AgentConfiguration;
+    capabilities?: AgentCapabilities;
+}
+
+/** Catalog-facing specification fields for an agent (application) deployment. */
+export declare interface AgentSpecification {
+    provider?: string;
+    vendor?: string;
+    license?: string;
+    knowledgeCutoffDate?: string;
+    parameters?: string;
+    hostedBy?: string;
+    createdAt?: number;
+    routes?: string[];
+}
+
+/** Toolset authentication mechanism as reported by DIAL Core. */
+export declare enum AuthenticationType {
+    None = "NONE",
+    ApiKey = "API_KEY",
+    OAuth = "OAUTH"
+}
+
+/** Builds the MCP endpoint URL for an application-deployment resource. */
+export declare const buildApplicationMcpUrl: (baseUrl: string, id: string) => string;
+
+/** Builds the OpenAI-compatible Chat Completions endpoint URL for a deployment. */
+export declare const buildChatCompletionsUrl: (baseUrl: string, id: string) => string;
+
+/** Builds the "Connect" tab's resource/endpoint/snippet data for the MCP endpoint of the given resource kind. */
+export declare const buildConnectApi: (baseUrl: string, id: string, kind: McpResourceKind) => CatalogItemApiDetails;
+
+/**
+ * Builds the "Connect" tab's endpoint list for a model or application
+ * deployment: the OpenAI-compatible Chat Completions endpoint and/or the
+ * Responses API endpoint, each included only when the deployment reports
+ * supporting it. DIAL Core routes both APIs the same way for models and
+ * custom applications, keyed by the deployment id.
+ */
+export declare const buildDeploymentConnectApi: (baseUrl: string, id: string, { hasChatCompletion, hasResponsesApi }: DeploymentGenerationApiSupport) => CatalogItemApiDetails | undefined;
+
+/**
+ * Builds the Overview tab data for a prompt: who authored it and when it last
+ * changed. The description is not repeated here — the Details tab already
+ * shows it above the body.
+ */
+export declare const buildPromptOverview: (prompt: PromptResponseDto, labels: PromptOverviewLabels) => CatalogItemOverview;
+
+/** Builds the Responses API endpoint URL for a deployment. */
+export declare const buildResponsesUrl: (baseUrl: string) => string;
+
+/**
+ * Builds the Content tab's hierarchical file tree for a skill from
+ * `listSkillFiles({ recursive: true })`'s flat listing. Every entry's path is
+ * first stripped of the skill's own path prefix and its internal `files`
+ * storage directory (see `stripSkillPathPrefix`) — the skill's own root
+ * folder and that `files` directory are Core storage implementation details,
+ * not authored structure, so neither appears as a wrapping node. An entry
+ * that strips to nothing (the skill root, or the bare `files` directory
+ * 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
+ * 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.
+ */
+export declare const buildSkillContentTree: (files: SkillMetadataItemDto[], skillPath: string) => CatalogContentTreeNode[];
+
+/**
+ * Builds the Overview tab data for a skill: a Specification section from its
+ * parsed manifest frontmatter, followed by a Details section covering who
+ * 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.
+ */
+export declare const buildSkillOverview: (skill: SkillMetadataItemDto | undefined, files: SkillMetadataItemDto[], about: SkillAboutDetails | undefined, labels: SkillOverviewLabels) => CatalogItemOverview;
+
+/** Builds the MCP endpoint URL for a toolset resource. */
+export declare const buildToolsetMcpUrl: (baseUrl: string, id: string) => string;
+
+/** Injected API port for catalog item detail fetching. Mirrors exact server-api wrapper signatures. */
+export declare interface CatalogDetailsApi {
+    /** Fetches deployment-level details for a model, agent, toolset, or application. */
+    getDeploymentDetails(deploymentId: string): Promise<DeploymentDetailsDto>;
+    /** Fetches rate-limit data for a deployment. */
+    getDeploymentLimits(deploymentId: string): Promise<DeploymentLimitsResponseDto>;
+    /** Fetches a personal or shared prompt by its full `prompts/{bucket}/{path}` resource id. */
+    getPrompt(id: string): Promise<PromptResponseDto>;
+    /** Fetches a public (organisation) prompt by its bucket-relative path. */
+    getPublicPrompt(path: string): Promise<PromptResponseDto>;
+    /** Downloads a raw skill file, returning the raw fetch `Response`. */
+    downloadSkillFile(bucket: string, path: string, filePath: string, signal?: AbortSignal): Promise<Response>;
+    /** Lists files inside a skill package. */
+    listSkillFiles(params: {
+        bucket: string;
+        filePath: string;
+        path?: string;
+        token?: string;
+        limit?: number;
+        recursive?: boolean;
+    }, signal?: AbortSignal): Promise<SkillFileListResponseDto>;
+}
+
+/** Primary action resolved for a deployment (model, agent, toolset, or skill). */
+export declare interface CatalogPrimaryActionDeployment {
+    /** Discriminant. */
+    kind: CatalogPrimaryActionType.Deployment;
+    /** Deployment entity id. */
+    id: string;
+}
+
+/** Primary action resolved for a prompt. */
+export declare interface CatalogPrimaryActionPrompt {
+    /** Discriminant. */
+    kind: CatalogPrimaryActionType.Prompt;
+    /** Prompt entity id. */
+    id: string;
+    /** Display name of the prompt. */
+    name: string;
+    /** Short description of the prompt. */
+    description: string;
+    /** Resolved prompt body (seeded from details or fetched). */
+    content: string;
+    /** Whether the prompt body contains at least one `{{parameter}}` placeholder. */
+    hasParameters: boolean;
+}
+
+/** Discriminated union of catalog primary-action results. */
+export declare type CatalogPrimaryActionResult = CatalogPrimaryActionDeployment | CatalogPrimaryActionPrompt;
+
+/** Discriminant for primary-action result variants. */
+export declare enum CatalogPrimaryActionType {
+    Deployment = "deployment",
+    Prompt = "prompt"
+}
+
+/**
+ * The publish API's entity-type path param values. Re-declared as a plain
+ * string-literal union rather than importing the generated
+ * `PublishCatalogEntityEntityTypeEnum`, so this module has no dependency on
+ * the app's own `server-api` layer.
+ */
+export declare type CatalogPublishEntityType = 'model' | 'toolset' | 'application' | 'prompt' | 'skill';
+
+/**
+ * Wraps the generated `PublishApi` in the positional-argument surface the
+ * catalog and conversation publish flows call, so each host app re-exports one
+ * client instead of re-declaring the same four wrappers. Mirrors
+ * {@link createFilesApiClient}.
+ */
+export declare const createPublishApiClient: (publishApi: PublishApi) => PublishApiClient;
+
+/** Translated folder-path labels for the Personal/Shared/Public deployment groupings. */
+export declare interface DeploymentFolderLabels {
+    personal: string;
+    shared: string;
+    public: string;
+}
+
+/** Which generation APIs a deployment reports supporting. */
+export declare interface DeploymentGenerationApiSupport {
+    hasChatCompletion?: boolean;
+    hasResponsesApi?: boolean;
+}
+
+/** Labels and formatter callbacks for the deployment-limits mapping utility. */
+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. */
+    tokensPerDay: string;
+    /** Label for the tokens-per-week stat row. */
+    tokensPerWeek: string;
+    /** Label for the tokens-per-month stat row. */
+    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. */
+    formatProgressAriaLabel: (params: {
+        label: string;
+        used: string;
+        total: string;
+    }) => string;
+    /** Formats the ARIA label for an unlimited row, which has no total to announce. */
+    formatFollowsCostLimitAriaLabel: (params: {
+        label: string;
+        used: string;
+    }) => string;
+}
+
+/**
+ * Returns the subset of `tabOrder` entries whose entity type is present in
+ * `items`, preserving tab order.
+ */
+export declare const deriveAvailableTabIds: <T extends CatalogEntityType>(items: readonly CatalogItem[], tabOrder: readonly T[]) => T[];
+
+/**
+ * Returns items marked as a user favorite, in original order.
+ */
+export declare const deriveFavoriteItems: (items: readonly CatalogItem[]) => CatalogItem[];
+
+/**
+ * Percent-encodes each `/`-separated segment of a deployment/application id
+ * so it satisfies the backend's `DEPLOYMENT_ID_PATTERN` (spaces and other
+ * reserved characters must be percent-encoded; `/` stays a literal path
+ * separator). Applications created via `POST /api/v1/applications` return an
+ * id built from the raw, human-readable name (e.g. `applications/<bucket>/My
+ * App__1.0`), which is only ever consumed by the settings iframe's postMessage
+ * protocol elsewhere — anywhere that id is used as a chat `deploymentId`, it
+ * must be encoded first.
+ */
+export declare const encodeDeploymentId: (id: string) => string;
+
+/** Discriminated-union entity details for a deployment, keyed by catalog entity type. */
+export declare type EntitySpecificDetails = {
+    type: 'MODEL';
+    data: ModelEntityDetails;
+} | {
+    type: 'AGENT';
+    data: AgentEntityDetails;
+} | {
+    type: 'TOOLSET';
+    data: ToolsetEntityDetails;
+};
+
+/** Entity kind used to route a favorite toggle to the correct backend section. */
+export declare enum FavoriteEntityType {
+    Deployment = "deployment",
+    Toolset = "toolset",
+    Prompt = "prompt",
+    Skill = "skill"
+}
+
+/** Raw favorites payload returned by `loadFavorites`. */
+export declare interface FavoritesPayload {
+    deployments: string[];
+    toolsets: string[];
+    prompts: string[];
+    skills: string[];
+}
+
+/**
+ * Filters catalog items to those whose type is in `visibleTypes`.
+ * Call only when selector mode is active; otherwise pass through the original array.
+ */
+export declare const filterCatalogItemsBySelector: (items: readonly CatalogItem[], visibleTypes: ReadonlySet<CatalogEntityType>) => CatalogItem[];
+
+/**
+ * Filters out items owned by the current user when `hideOwned` is true.
+ * Always returns a new array so callers may safely assign to mutable collections.
+ */
+export declare const filterHiddenOwnedItems: (items: readonly CatalogItem[], hideOwned: boolean) => CatalogItem[];
+
+/**
+ * Finds a deployment matching `idOrReference` by `id` first, falling back to
+ * `reference` when no `id` matches. DIAL Core sometimes addresses a
+ * deployment by `reference` in places that store a deployment id (e.g. a
+ * conversation's or message's `model.id`), so lookups against the fetched
+ * deployments list must accept either value.
+ */
+export declare const findDeploymentByIdOrReference: (deployments: DeploymentItemDto[], idOrReference: string | null | undefined) => DeploymentItemDto | undefined;
+
+/**
+ * Whether a prompt item came from the organisation namespace, which the public
+ * prompt endpoints serve. Personal prompts resolve through the caller's own
+ * bucket, while shared prompts carry their owner's bucket in the resource URL.
+ */
+export declare const isOrganisationPromptItem: (item: CatalogItem) => boolean;
+
+/**
+ * Converts the backend `DeploymentDetailsDto` (model/application/toolset,
+ * fetched by id) into the strongly-typed `EntitySpecificDetails` domain model
+ * consumed by `mapEntityDetailsToCatalogDetails`.
+ */
+export declare const mapDeploymentDetailsDtoToEntityDetails: (dto: DeploymentDetailsDto) => EntitySpecificDetails;
+
+/** 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 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;
+
+/** Parameters for {@link mapDeploymentToCatalogItem}. */
+export declare interface MapDeploymentToCatalogItemOptions {
+    favoriteIds?: ReadonlySet<string>;
+    entityDetails?: EntitySpecificDetails;
+    folderLabels: DeploymentFolderLabels;
+    editableSchemaIds?: string[];
+    isCustomAppsEditable?: boolean;
+    /** The viewer's active display locale, used to resolve `displayName`/`description`. */
+    activeLocale: string;
+    /** The fixed content language `displayName`/`description` fall back to when `activeLocale` has no entry. */
+    primaryLocale: string;
+    /** Resolves a deployment's raw `iconUrl` to a displayable URL. Host-owned. */
+    resolveIconUrl: (iconUrl: string | undefined) => string | undefined;
+}
+
+/**
+ * Maps a toolset's auth settings (from a deployment listing row) into the
+ * lib's credential-status shape, including both `USER` and `GLOBAL` sign-in
+ * status, whether the toolset is public, and whether the current user (if an
+ * admin) may manage both levels. Named apart from
+ * `map-entity-details-to-catalog.ts`'s `mapToolsetCredentials` (a different
+ * input shape, `ToolsetEntityDetails`) to avoid an ambiguous `export *`
+ * collision between the two modules.
+ *
+ * For a non-admin on a public toolset that already has `GLOBAL` credentials
+ * signed in, the lib's own `LoginWithMyCreds` CTA fires unconditionally off
+ * `isPublic` alone, regardless of whether org-wide credentials already cover
+ * everyone (`node_modules/@epam/ai-dial-catalog/dist/index.js`, the `ct`
+ * helper). Global auth is sufficient to use the toolset — a personal login
+ * is optional, not required — so this suppresses that CTA by reporting
+ * `authenticationType: None`, which is the lib's own documented signal to
+ * hide the credentials control entirely.
+ */
+export declare const mapDeploymentToolsetCredentials: (toolsetId: string, authSettings: DialToolsetAuthSettingsDto | undefined, isAdmin: boolean) => CatalogItemCredentials | undefined;
+
+/**
+ * Converts a strongly-typed entity domain model into the lib's `CatalogItemTabData` shape.
+ * Every label is a fixed English string — the app's i18n keys for these labels are dropped
+ * on the move, since the lib cannot import the app's translation-key enum.
+ */
+export declare const mapEntityDetailsToCatalogDetails: (details: EntitySpecificDetails) => CatalogItemTabData;
+
+/**
+ * Maps a prompt DTO into a catalog item.
+ *
+ * `prompt.id` is already the full `prompts/{bucket}/{path}` resource path —
+ * the owner bucket for a shared-with-me prompt, the caller's own bucket
+ * otherwise — the same shape every other resource type's `CatalogItem.id`
+ * carries, so no per-source qualification is needed here.
+ */
+export declare const mapPromptToCatalogItem: (prompt: PromptResponseDto, { folderLabels, overviewLabels, source, favoriteIds, }: MapPromptToCatalogItemOptions) => CatalogItem;
+
+/** Parameters for {@link mapPromptToCatalogItem}. */
+export declare interface MapPromptToCatalogItemOptions {
+    /** Personal/Shared/Public folder labels; i18n stays at the app edge. */
+    folderLabels: DeploymentFolderLabels;
+    /** Author/updated/section-title labels for the Overview tab; i18n stays at the app edge. */
+    overviewLabels: PromptOverviewLabels;
+    /** Namespace the prompt came from; drives ownership flags and the folder prefix. */
+    source: PromptSource;
+    /** Favorited resource ids from the user config, keyed by prompt path. */
+    favoriteIds: ReadonlySet<string>;
+}
+
+/** Maps a conversation publish-history API response entry to the publish panel's `PublishHistoryEntry` model. */
+export declare const mapPublishConversationResultDto: (dto: PublishConversationResultDto) => PublishHistoryEntry;
+
+/** Maps a publish-history API response entry to the catalog lib's `PublishHistoryEntry` model. */
+export declare const mapPublishHistoryEntryDto: (dto: PublishHistoryEntryDto) => PublishHistoryEntry;
+
+/**
+ * Maps a skill's DIAL Core metadata into a catalog item. The full
+ * `skills/{bucket}/{path}` resource URL is used as `CatalogItem.id` rather
+ * than the bucket-relative path: the catalog lists two buckets, and the same
+ * relative path can exist in both.
+ */
+export declare const mapSkillToCatalogItem: (skill: SkillMetadataItemDto, { folderLabels, source, favoriteIds }: MapSkillToCatalogItemOptions) => CatalogItem;
+
+/** Parameters for {@link mapSkillToCatalogItem}. */
+export declare interface MapSkillToCatalogItemOptions {
+    /** Personal/Shared/Public folder labels; i18n stays at the app edge. */
+    folderLabels: DeploymentFolderLabels;
+    /** Namespace the skill came from; drives ownership flags and the folder prefix. */
+    source: SkillSource;
+    /** Favorited resource ids from the user config, keyed by skill resource URL. */
+    favoriteIds: ReadonlySet<string>;
+}
+
+/**
+ * Maps a toolset's specification into the lib's credential-status shape,
+ * for refreshing the details panel after login/logout. Includes both
+ * `USER` and `GLOBAL` status, whether the toolset is public, and whether
+ * the current user (if an admin) may manage both levels.
+ */
+export declare const mapToolsetCredentials: (toolsetId: string, data: ToolsetEntityDetails, isAdmin: boolean) => CatalogItemCredentials | undefined;
+
+/** Maps a toolset listing row into the catalog UI's `CatalogItem` shape. */
+export declare const mapToolsetToCatalogItem: (toolset: DialToolsetDto, { favoriteIds, isAdmin, folderLabels, activeLocale, primaryLocale, resolveIconUrl, }: MapToolsetToCatalogItemOptions) => CatalogItem;
+
+/** Parameters for {@link mapToolsetToCatalogItem}. */
+export declare interface MapToolsetToCatalogItemOptions {
+    favoriteIds?: ReadonlySet<string>;
+    isAdmin?: boolean;
+    folderLabels?: DeploymentFolderLabels;
+    /** The viewer's active display locale, used to resolve `displayName`/`description`. */
+    activeLocale: string;
+    /** The fixed content language `displayName`/`description` fall back to when `activeLocale` has no entry. */
+    primaryLocale: string;
+    /** Resolves a toolset's raw `iconUrl` to a displayable URL. Host-owned. */
+    resolveIconUrl: (iconUrl: string | undefined) => string | undefined;
+}
+
+/** Resource families that DIAL Core exposes an MCP endpoint for. */
+export declare enum McpResourceKind {
+    /** Toolsets, served under `/v1/toolset/{id}/mcp`. */
+    Toolset = "toolset",
+    /** Application deployments, served under `/v1/deployments/{id}/mcp`. */
+    Application = "application"
+}
+
+/** API-resource identifiers for a model deployment. */
+export declare interface ModelApiDetails {
+    modelId?: string;
+}
+
+/** Feature-support flags for a model deployment. */
+export declare interface ModelCapabilities {
+    hasTools?: boolean;
+    hasMcp?: boolean;
+    hasCaching?: boolean;
+    hasParallelToolCalls?: boolean;
+    hasUrlAttachments?: boolean;
+    hasFolderAttachments?: boolean;
+    hasSeed?: boolean;
+    hasSystemPrompt?: boolean;
+    hasResume?: boolean;
+    hasChatCompletion?: boolean;
+    hasResponsesApi?: boolean;
+    reasoningEfforts?: string[];
+}
+
+/** Full details payload for a model-type deployment. */
+export declare interface ModelEntityDetails {
+    capabilities?: ModelCapabilities;
+    specification?: ModelSpecification;
+    pricing?: ModelPricing;
+    api?: ModelApiDetails;
+}
+
+/** One priced unit for a model deployment. */
+export declare interface ModelPriceRow {
+    /** DIAL Core pricing key, e.g. `prompt`, `completion`, `cache_read`. */
+    key: string;
+    /** Per-unit price formatted for display, e.g. `$3/M tokens`. */
+    price: string;
+}
+
+/** A model deployment's full price list. */
+export declare interface ModelPricing {
+    /** Every price DIAL Core reports for the deployment, `unit` excluded. */
+    prices?: ModelPriceRow[];
+}
+
+/** Catalog-facing specification fields for a model deployment. */
+export declare interface ModelSpecification {
+    provider?: string;
+    vendor?: string;
+    license?: string;
+    knowledgeCutoffDate?: string;
+    parameters?: string;
+    contextWindowTokens?: number;
+    maxOutputTokens?: number;
+    inputTypes?: string[];
+    hostedBy?: string;
+    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;
+}
+
+/** A skill resource URL split into the bucket and the path within it. */
+export declare interface ParsedSkillResourceUrl {
+    /** DIAL Core bucket name. */
+    bucket: string;
+    /** Path to the skill within that bucket. */
+    path: string;
+}
+
+/**
+ * Splits a `skills/{bucket}/{path}` resource URL into its parts, mirroring the
+ * backend's parser. Returns `null` for a different prefix, an empty bucket, or
+ * an empty path, so callers can treat "not a skill URL" as one case.
+ */
+export declare const parseSkillResourceUrl: (url: string) => ParsedSkillResourceUrl | null;
+
+/** Translated labels for the Overview tab's author/updated rows and section title. */
+export declare interface PromptOverviewLabels {
+    authorLabel: string;
+    updatedLabel: string;
+    sectionTitle: string;
+}
+
+/** Which prompt namespace a catalog prompt item came from. */
+declare enum PromptSource {
+    /** The caller's own prompt, editable and deletable by them. */
+    Personal = "personal",
+    /** Shared with the caller by another user; permissions determine editability. */
+    SharedWithMe = "sharedWithMe",
+    /** Organisation-wide prompt; read-only for every user. */
+    Public = "public"
+}
+
+/** DIAL Core bucket holding organisation-wide skills. */
+export declare const PUBLIC_SKILL_BUCKET = "public";
+
+/** The DIAL publish API surface produced by {@link createPublishApiClient}. */
+export declare interface PublishApiClient {
+    /** Submits a publication request for one catalog entity into `folderPath`. */
+    publishCatalogEntity: (entityType: CatalogPublishEntityType, entityId: string, body: PublishCatalogEntityDto) => Promise<PublishResultDto>;
+    /**
+     * Submits a removal request for one already-published folder of a catalog
+     * entity. The removal takes effect only after an administrator approves it,
+     * so callers must report a pending request rather than a completed removal.
+     */
+    unpublishCatalogEntity: (entityType: CatalogPublishEntityType, entityId: string, body: UnpublishCatalogEntityDto) => Promise<UnpublishResultDto>;
+    /** Reads the folders one catalog entity is already published to. */
+    getCatalogPublishHistory: (entityType: CatalogPublishEntityType, entityId: string) => Promise<PublishHistoryEntryDto[]>;
+    /** Reads a destination folder's already-configured access rules. */
+    getPublishRules: (folderPath: string) => Promise<PublicationRule[]>;
+}
+
+/**
+ * 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
+ * checked first so an oversized body is never read into memory at all; the
+ * actual byte length is checked again after reading, for a response with no
+ * (or an inaccurate) declared length. Applies identically to every skill
+ * file, text or binary — not only `SKILL.md`.
+ */
+export declare const readSkillFileBytes: (response: Response) => Promise<Uint8Array | null>;
+
+/**
+ * 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
+ * oversized manifest is never turned into a string.
+ */
+export declare const readSkillManifest: (response: Response) => Promise<string | null>;
+
+/**
+ * Returns the intersection of `persistedTopics` with topics that appear in
+ * `items`. Returns a new Set and never mutates either input.
+ */
+export declare const reconcileFilterTopics: (persistedTopics: ReadonlySet<string>, items: readonly CatalogItem[]) => Set<string>;
+
+/**
+ * Resolves the primary action for a catalog item.
+ *
+ * For prompts: prefers already-seeded content from `item.details`; otherwise
+ * calls `fetchPrompt` once to retrieve the body. Sets `hasParameters` based on
+ * whether the content contains prompt-parameter placeholders.
+ *
+ * For all other entity types: returns a deployment result with the item id.
+ *
+ * The function does not navigate, select a deployment, show notifications, or
+ * import route constants — those remain the caller's responsibility.
+ *
+ * @throws When `fetchPrompt` rejects (propagated to the caller without wrapping).
+ */
+export declare const resolveCatalogPrimaryAction: (item: CatalogItem, fetchPrompt: (item: CatalogItem) => Promise<PromptResponseDto>) => Promise<CatalogPrimaryActionResult>;
+
+export declare const resolveDeploymentFolder: (deployment: Pick<DeploymentItemDto, "isMy" | "sharedWithMe" | "applicationFolder">, labels: DeploymentFolderLabels) => string[];
+
+/** Returns the MCP resource kind a catalog item's Connect endpoint belongs to, or `null` when the item exposes no MCP endpoint. */
+export declare const resolveMcpResourceKind: (type: CatalogEntityType, supportsMcp?: boolean) => McpResourceKind | null;
+
+/**
+ * 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
+ * internal `files` directory, while the endpoint accepts a path relative to
+ * that directory. File-relative ids are returned unchanged.
+ */
+export declare const resolveSkillFileDownloadPath: (fileId: string, skillPath: string) => string | null;
+
+/**
+ * Resolves the manifest file's opaque listing id across DIAL Core versions.
+ * Some return file-relative paths (`SKILL.md`), while others prefix the
+ * skill's path and its internal `files` directory. The returned id is kept
+ * verbatim so it matches the corresponding tree node exactly.
+ */
+export declare const resolveSkillManifestFileId: (files: SkillMetadataItemDto[], skillPath: string) => string;
+
+/**
+ * Upper bound on `nextToken` follow-ups per listing, so a pathological bucket
+ * cannot spin the client forever.
+ */
+export declare const SKILL_LISTING_MAX_PAGES = 10;
+
+/** Items requested per skill-listing page. */
+export declare const SKILL_LISTING_PAGE_SIZE = 1000;
+
+/**
+ * Largest manifest the details panel will decode. A `SKILL.md` past this is
+ * treated as unreadable rather than rendered.
+ */
+export declare const SKILL_MANIFEST_MAX_BYTES: number;
+
+/** Structured fields lifted from a skill manifest's frontmatter. */
+declare interface SkillAboutDetails {
+    whenToUse?: string;
+    allowedTools?: string[];
+    bundledResources?: string[];
+    skillPrompt?: string;
+}
+
+/** A skill's parsed manifest details. */
+export declare interface SkillEntityDetails {
+    about?: SkillAboutDetails;
+}
+
+/**
+ * In-memory bytes for a Skill supporting file, plus its MIME type when known
+ * (e.g. from a browser upload's `File.type`).
+ */
+declare interface SkillFileContent {
+    /** The file's raw bytes. */
+    bytes: Uint8Array;
+    /**
+     * MIME type from the original browser `File.type`. Omit for edit-mode ZIP
+     * entries, which carry no MIME metadata — the type is then inferred from
+     * the file's path.
+     */
+    mimeType?: string;
+}
+
+/** Translated labels for the skill Overview tab's Specification/Details sections. */
+export declare interface SkillOverviewLabels {
+    whenToUseLabel: string;
+    allowedToolsLabel: string;
+    bundledResourcesLabel: string;
+    specificationSectionTitle: string;
+    authorLabel: string;
+    updatedLabel: string;
+    fileCountLabel: string;
+    detailsSectionTitle: string;
+}
+
+/** Discriminant for the kind of error a `useSkillFilePreview` load can produce. */
+export declare enum SkillPreviewErrorKind {
+    /** HTTP 403 — the caller lacks permission to read this file. */
+    Forbidden = "forbidden",
+    /** Any non-403 load failure. */
+    Generic = "generic"
+}
+
+/** Which skill namespace a catalog skill item came from. */
+export declare enum SkillSource {
+    /** A skill in the caller's own bucket. */
+    Personal = "personal",
+    /** A skill another user shared with the caller. */
+    SharedWithMe = "sharedWithMe",
+    /** An organisation-wide skill; read-only for every user. */
+    Public = "public"
+}
+
+/** Sign-in status at both the personal and org-wide (global) level for a toolset. */
+export declare interface ToolsetAuthStatusDetails {
+    global?: string;
+    appLevel?: string;
+    userLevel?: string;
+    scopesSupported?: string[];
+    authorizationEndpoint?: string;
+    tokenEndpoint?: string;
+    apiKeyHeader?: string;
+}
+
+/** Feature-support flags for a toolset. */
+export declare interface ToolsetCapabilities {
+    hasMcp?: boolean;
+    hasCaching?: boolean;
+    hasSystemPrompt?: boolean;
+    hasResume?: boolean;
+}
+
+/** Full details payload for a toolset-type deployment. */
+export declare interface ToolsetEntityDetails {
+    specification?: ToolsetSpecification;
+    capabilities?: ToolsetCapabilities;
+}
+
+/** Catalog-facing specification fields for a toolset. */
+export declare interface ToolsetSpecification {
+    provider?: string;
+    vendor?: string;
+    license?: string;
+    knowledgeCutoffDate?: string;
+    parameters?: string;
+    authentication?: AuthenticationType;
+    permissions?: string[];
+    hostedBy?: string;
+    authStatus?: ToolsetAuthStatusDetails;
+    createdAt?: number;
+    /** Names of all tools the underlying MCP server supports, not just the allow-listed subset in `permissions`. */
+    allTools?: string[];
+}
+
+/** Maps a catalog item's entity type to the publish API's entity-type path param, or `undefined` if that type is not publishable. */
+export declare const toPublishEntityType: (type: CatalogEntityType) => CatalogPublishEntityType | undefined;
+
+/**
+ * Converts a `PublicationRule` (publish-panel lib model) to the generated
+ * client's `PublishRuleDto` shape. The two differ only in how the comparison
+ * function is typed, so the value passes through unchanged.
+ */
+export declare const toPublishRuleDto: (rule: PublicationRule) => PublishRuleDto;
+
+/**
+ * Headless hook that encapsulates catalog item detail fetching.
+ * Extracts the inline dispatch logic from `CatalogView` into a reusable,
+ * library-isolated unit.
+ */
+export declare const useCatalogItemDetails: ({ api, skills, isAdmin, dialCoreExternalUrl, skillOverviewLabels, promptOverviewLabels, deploymentLimitsLabels, }: UseCatalogItemDetailsOptions) => UseCatalogItemDetailsResult;
+
+/** Options accepted by `useCatalogItemDetails`. */
+export declare interface UseCatalogItemDetailsOptions {
+    /** Configured API adapter used for all network calls. */
+    api: CatalogDetailsApi;
+    /**
+     * Combined array of all skills visible to this user
+     * (personal + shared + public) for overview metadata lookup.
+     */
+    skills: SkillMetadataItemDto[];
+    /** Whether the current user has admin privileges (affects toolset credential visibility). */
+    isAdmin: boolean;
+    /** DIAL Core external base URL used for Connect-tab endpoint construction. */
+    dialCoreExternalUrl: string | null | undefined;
+    /** Labels for skill overview section headers. */
+    skillOverviewLabels: SkillOverviewLabels;
+    /** Labels for prompt overview section headers. */
+    promptOverviewLabels: PromptOverviewLabels;
+    /** Labels for deployment limits table. */
+    deploymentLimitsLabels: DeploymentLimitsLabels;
+}
+
+/** Returned callbacks from `useCatalogItemDetails`. All callbacks are stable for stable inputs. */
+export declare interface UseCatalogItemDetailsResult {
+    /**
+     * Fetches full detail data for a catalog item.
+     * Returns `undefined` on failure (error handled by caller).
+     */
+    onFetchDetails(item: CatalogItem): Promise<CatalogItemDetailsFetchResult | undefined>;
+    /**
+     * Loads the text content of a file inside the currently open skill's package.
+     * Returns `undefined` when the file cannot be read or is a directory.
+     */
+    onLoadContentFile(fileId: string): Promise<string | undefined>;
+    /**
+     * Downloads and returns preview bytes for a file inside the currently open skill's package.
+     * Throws on HTTP errors, unparseable ids, and size-limit violations.
+     */
+    onLoadSkillDetailsFile(fileId: string): Promise<SkillFileContent>;
+}
+
+/**
+ * Manages the set of favorited entity ids: loads on mount, applies optimistic
+ * toggle with exact-inverse rollback on failure, and re-throws persistence
+ * errors so callers can react. Does not import any app context or server-api.
+ */
+export declare const useFavoriteEntitiesState: ({ loadFavorites, updateFavorite, }: UseFavoriteEntitiesStateParams) => UseFavoriteEntitiesStateResult;
+
+/** Parameters for {@link useFavoriteEntitiesState}. */
+export declare interface UseFavoriteEntitiesStateParams {
+    /** Fetches the initial set of favorite ids from the server. */
+    loadFavorites: () => Promise<FavoritesPayload>;
+    /** Persists a single favorite toggle for the given entity type. */
+    updateFavorite: (id: string, isFavorite: boolean, entityType: FavoriteEntityType) => Promise<void>;
+}
+
+/** Result returned by {@link useFavoriteEntitiesState}. */
+export declare interface UseFavoriteEntitiesStateResult {
+    /** Union of all installed entity ids across every category. */
+    favoriteIds: ReadonlySet<string>;
+    /** True until the initial load has settled. */
+    isLoading: boolean;
+    /** Optimistically toggles a favorite and rolls back on persistence failure. */
+    toggleFavorite: (id: string, isFavorite: boolean, entityType?: FavoriteEntityType) => Promise<void>;
+}
+
+/**
+ * Loads the Organization/public bucket's folder tree lazily (one listing per
+ * expanded folder, cached by API path) for the Publish flow's folder picker,
+ * shared by catalog-entity publish and conversation publish. Scoped to folders
+ * only — unlike `useDialFileManager`, it does not list files, rename,
+ * copy/move, or upload.
+ *
+ * Destinations the user has already published to are merged into that tree
+ * from `rememberedFolderKeys`. Publishing creates a DIAL Core publication
+ * *request*, so a folder picked during publish is not a listable resource in
+ * the public files bucket this tree is built from — the remembered list is
+ * what keeps such a folder selectable for the next publish instead of
+ * vanishing when the panel is reopened.
+ *
+ * Takes `listPublicFiles` as a parameter and hands remembered destinations
+ * back through a callback, so it imports no app context and no storage API.
+ */
+export declare const usePublishFolders: ({ listPublicFiles, rememberedFolderKeys, onRememberedFolderKeysChange, }: UsePublishFoldersParams) => UsePublishFoldersResult;
+
+/** Parameters for {@link usePublishFolders}. */
+export declare interface UsePublishFoldersParams {
+    /** Lists one folder level of the Organization/public files bucket. */
+    listPublicFiles: (params: {
+        path?: string;
+    }) => Promise<ListFilesResponseDto>;
+    /**
+     * Folder path keys (`path.join('/')`) the user has published to before.
+     * Owned by the host, which is also what persists them — this hook never
+     * touches browser storage (library isolation).
+     */
+    rememberedFolderKeys?: string[];
+    /**
+     * Called with the next remembered-key list when {@link
+     * UsePublishFoldersResult.rememberPublishFolder} records a destination.
+     * Omit it for a host that does not persist destinations.
+     */
+    onRememberedFolderKeysChange?: (folderKeys: string[]) => void;
+}
+
+/** Result returned by {@link usePublishFolders}. */
+export declare interface UsePublishFoldersResult {
+    /** Folder tree loaded so far from the Organization/public bucket. */
+    folderItems: PublishFolderNode[];
+    /** Folder path keys currently expanded in the tree. */
+    expandedPaths: Set<string>;
+    /** Folder path keys whose children have already been fetched. */
+    loadedPaths: Set<string>;
+    /** Folder path keys currently being fetched. */
+    loadingPaths: Set<string>;
+    /** Called by the folder tree when the set of expanded folders changes. */
+    onExpandedPathsChange: (paths: Set<string>) => void;
+    /**
+     * Adds a folder under `parentPath` to the in-memory tree only — it is
+     * never created on the backend here. The path becomes real once the user
+     * actually publishes to it: the publish request writes to the nested
+     * `folderPath`, which DIAL Core storage creates implicitly, the same way
+     * writing a file to a new prefix does. This avoids leaving an orphaned
+     * empty folder behind when the user picks a new-folder name and then
+     * cancels the publish. Because the folder exists only locally, it is kept
+     * apart from the listing cache, so a listing that arrives afterwards
+     * cannot drop it again.
+     */
+    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.
+     */
+    rememberPublishFolder: (folderPath: string[]) => void;
+    /** Heuristic write-access check for a folder path (see the TODO above). */
+    hasPublishWriteAccess: (folderPath: string[]) => boolean;
+}
+
+/**
+ * Headless hook that manages the skill-file preview loading lifecycle.
+ * Starts a new load on mount and whenever `fileId` changes; classifies errors
+ * as `Forbidden` (HTTP 403) or `Generic`; discards settlements from superseded
+ * or unmounted loads.
+ */
+export declare const useSkillFilePreview: ({ fileId, onLoadFile, }: UseSkillFilePreviewOptions) => UseSkillFilePreviewResult;
+
+/** Options accepted by `useSkillFilePreview`. */
+export declare interface UseSkillFilePreviewOptions {
+    /**
+     * Opaque id of the selected skill file. Changing this resets all state
+     * and starts a new load; stale resolutions from the previous id are discarded.
+     */
+    fileId: string;
+    /**
+     * App-owned loader; resolves with the raw file bytes when the request
+     * succeeds. The hook never constructs a URL or imports a REST client.
+     */
+    onLoadFile: (fileId: string) => Promise<SkillFileContent>;
+}
+
+/** State returned by `useSkillFilePreview`. */
+export declare interface UseSkillFilePreviewResult {
+    /** `true` while the async load is in flight. */
+    isLoading: boolean;
+    /** Resolved file content, or `null` while loading or after an error. */
+    content: SkillFileContent | null;
+    /** Classified load error, or `null` while loading or after a success. */
+    error: SkillPreviewErrorKind | null;
+}
+
+export { }