@knkcs/mediahub-ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1686 @@
+import { default as default_2 } from 'react';
+import { JSX } from 'react';
+import { PersistOptions } from 'zustand/middleware';
+import { QueryClient } from '@tanstack/react-query';
+import { ReactNode } from 'react';
+import { StatusInfo } from '@knkcs/statushub-ui';
+import { StoreApi } from 'zustand';
+import { UseBoundStore } from 'zustand';
+import { UseMutateAsyncFunction } from '@tanstack/react-query';
+import { UseMutateFunction } from '@tanstack/react-query';
+import { UseMutationResult } from '@tanstack/react-query';
+import { UseQueryResult } from '@tanstack/react-query';
+
+export declare interface AddVersionVars {
+    assetId: string;
+    file: File;
+    comment?: string;
+}
+
+export declare interface AIConnectionClient {
+    list(workspaceId: string): Promise<AIConnectionInfo[]>;
+    get(id: string): Promise<AIConnectionInfo>;
+    create(params: {
+        workspaceId: string;
+        name: string;
+        provider: string;
+        endpoint: string;
+        deployment: string;
+        apiVersion: string;
+        baseUrl: string;
+        model: string;
+        apiKey: string;
+        description: string;
+    }): Promise<AIConnectionInfo>;
+    update(id: string, patch: {
+        name?: string;
+        endpoint?: string;
+        deployment?: string;
+        apiVersion?: string;
+        baseUrl?: string;
+        model?: string;
+        apiKey?: string;
+        description?: string;
+        active?: boolean;
+    }): Promise<AIConnectionInfo>;
+    delete(id: string): Promise<void>;
+}
+
+export declare interface AIConnectionInfo {
+    id: string;
+    workspaceId: string;
+    name: string;
+    provider: string;
+    endpoint: string;
+    deployment: string;
+    apiVersion: string;
+    baseUrl: string;
+    model: string;
+    description: string;
+    active: boolean;
+    hasApiKey: boolean;
+}
+
+export declare interface AIProcessClient {
+    list(assetTypeId: string): Promise<AIProcessInfo[]>;
+    get(id: string): Promise<AIProcessInfo>;
+    create(params: {
+        assetTypeId: string;
+        connectionId: string;
+        name: string;
+        prompt: string;
+        outputs: {
+            key: string;
+            target: string;
+            metadataAccessor: string;
+        }[];
+        position: number;
+        workspaceId: string;
+    }): Promise<AIProcessInfo>;
+    update(id: string, patch: {
+        connectionId?: string;
+        name?: string;
+        prompt?: string;
+        outputs?: {
+            key: string;
+            target: string;
+            metadataAccessor: string;
+        }[];
+        position?: number;
+        active?: boolean;
+    }): Promise<AIProcessInfo>;
+    delete(id: string): Promise<void>;
+}
+
+export declare interface AIProcessInfo {
+    id: string;
+    workspaceId: string;
+    assetTypeId: string;
+    connectionId: string;
+    name: string;
+    prompt: string;
+    outputs: {
+        key: string;
+        target: string;
+        metadataAccessor: string;
+    }[];
+    position: number;
+    active: boolean;
+}
+
+export declare interface AIProcessRunInfo {
+    id: string;
+    aiProcessId: string;
+    processName: string;
+    status: "queued" | "running" | "succeeded" | "failed" | string;
+    error: string;
+    startedAt?: Date;
+    finishedAt?: Date;
+}
+
+/**
+ * The catalogue an asset's status belongs to: mediahub's `asset` entity type,
+ * as registered with statushub at startup (integration standard §1).
+ *
+ * Every statushub-ui component and hook this package uses is pinned to it, so
+ * a host never names it and can never point a mediahub surface at another
+ * service's statuses. Exported because a host's settings screen embeds
+ * `StatusSettings` pinned to the same catalogue (§10) — `<StatusSettings
+ * {...ASSET_STATUS_CATALOGUE} />` — and one constant is how the two cannot
+ * come to disagree.
+ */
+export declare const ASSET_STATUS_CATALOGUE: {
+    readonly serviceSlug: "mediahub";
+    readonly entityTypeSlug: "asset";
+};
+
+export declare interface AssetClient {
+    list(workspaceId: string, filters: AssetFilters): Promise<Page<AssetInfo>>;
+    get(id: string): Promise<AssetInfo>;
+    create(workspaceId: string, params: CreateAssetParams): Promise<AssetInfo>;
+    update(id: string, patch: {
+        name?: string;
+        description?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AssetInfo>;
+    delete(id: string): Promise<void>;
+    getUploadUrl(params: GetUploadUrlParams): Promise<UploadTarget>;
+    finalizeUpload(versionId: string): Promise<AssetInfo>;
+    getDownloadUrl(assetId: string, versionId: string): Promise<string>;
+    move(id: string, folderId: string): Promise<AssetInfo>;
+    /**
+     * Changes an asset's status (statushub's integration standard §3).
+     * `fromStatusSlug` is the slug the caller last saw: the server makes the
+     * change against it, so a stale screen is refused as a conflict instead of
+     * overwriting whatever happened in between. Pass `""` when there is
+     * nothing to compare against.
+     */
+    transitionStatus(id: string, fromStatusSlug: string, toStatusSlug: string): Promise<AssetInfo>;
+    enhanceMetadata(id: string): Promise<AssetInfo>;
+    listProcessRuns(assetId: string): Promise<AIProcessRunInfo[]>;
+}
+
+export declare function AssetDetail({ assetId, onBack, onDeleted, }: AssetDetailProps): default_2.JSX.Element;
+
+export declare namespace AssetDetail {
+    var displayName: string;
+}
+
+export declare interface AssetDetailProps {
+    assetId: string;
+    /** Navigate back to the asset list. */
+    onBack?: () => void;
+    /** Called after a successful delete. */
+    onDeleted?: () => void;
+}
+
+export declare function AssetDetailRail({ assetId, assetName, currentVersionId, currentMimeType, currentFilename, currentFileSize, currentVersion, assetTypeId, createdBy, createdByName, folderId, tagIds, collectionIds, statusSlug, }: AssetDetailRailProps): default_2.JSX.Element;
+
+export declare namespace AssetDetailRail {
+    var displayName: string;
+}
+
+declare interface AssetDetailRailProps {
+    assetId: string;
+    assetName: string;
+    currentVersionId: string | undefined;
+    currentMimeType: string | undefined;
+    currentFilename: string | undefined;
+    currentFileSize: number | undefined;
+    currentVersion: number;
+    assetTypeId: string;
+    createdBy: string;
+    createdByName?: string;
+    folderId: string;
+    tagIds: string[];
+    collectionIds: string[];
+    statusSlug: string;
+}
+
+export declare interface AssetFilters {
+    folderId?: string;
+    assetTypeId?: string;
+    statusSlug?: string;
+    behavior?: AssetStatusBehavior;
+    search?: string;
+    tagIds?: string[];
+    collectionIds?: string[];
+}
+
+export declare const AssetGrid: React.FC<AssetGridProps>;
+
+export declare interface AssetGridProps {
+    assets: AssetInfo[];
+    onOpen: (asset: AssetInfo) => void;
+}
+
+export declare interface AssetInfo {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string;
+    statusSlug: string;
+    currentVersion: number;
+    metadata: Record<string, unknown>;
+    assetTypeId: string;
+    folderId: string;
+    createdBy: string;
+    updatedBy: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    versions: AssetVersionInfo[];
+    tagIds: string[];
+    collectionIds: string[];
+    analyzeWithAi: boolean;
+}
+
+export declare function AssetLibrary(props: AssetLibraryProps): React.JSX.Element;
+
+export declare namespace AssetLibrary {
+    var displayName: string;
+}
+
+export declare interface AssetLibraryProps {
+    onAssetOpen?: (asset: AssetInfo) => void;
+    initialFilters?: AssetFilters;
+    onFiltersChange?: (filters: AssetFilters) => void;
+}
+
+export declare function AssetPicker(props: AssetPickerProps): React.JSX.Element;
+
+export declare namespace AssetPicker {
+    var displayName: string;
+}
+
+export declare interface AssetPickerProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** @default "single" */
+    mode?: "single" | "multi";
+    onSelect: (selection: AssetSelection) => void;
+    /** Enable upload-then-select (wired in Task 5). */
+    allowUpload?: boolean;
+    /** Client-side MIME filter, e.g. ["image/*"] or ["application/pdf"]. */
+    accept?: string[];
+    /** Initial/locked filters (e.g. a fixed assetTypeId). */
+    initialFilters?: AssetFilters;
+    headerLabel?: string;
+    searchPlaceholder?: string;
+    insertLabel?: string;
+    cancelLabel?: string;
+    emptyLabel?: string;
+}
+
+export declare const AssetPreview: React.FC<AssetPreviewProps>;
+
+declare interface AssetPreviewProps {
+    assetId: string;
+    versionId: string;
+    mimeType: string;
+    fileName: string;
+}
+
+/** Result of confirming an AssetPicker selection. */
+export declare type AssetSelection = {
+    mode: "single";
+    asset: AssetInfo;
+} | {
+    mode: "multi";
+    assets: AssetInfo[];
+};
+
+/**
+ * An asset's status, named and coloured from statushub's catalogue.
+ *
+ * This is the one place mediahub turns a stored slug into something readable
+ * (statushub's integration standard §10: the consumer renders statuses itself,
+ * with statushub-ui's components — no host slot). A slug the catalogue does
+ * not carry — an **unknown status**, deleted or never answered for (§5) —
+ * prints as itself, because the asset has a status either way and saying
+ * nothing would read as having none.
+ */
+export declare function AssetStatusBadge({ slug }: AssetStatusBadgeProps): JSX.Element | null;
+
+export declare namespace AssetStatusBadge {
+    var displayName: string;
+}
+
+export declare interface AssetStatusBadgeProps {
+    /** The asset's stored status slug. Empty renders nothing. */
+    slug: string;
+}
+
+export declare type AssetStatusBehavior = "unspecified" | "active" | "archived" | "inactive" | "deleted";
+
+/**
+ * An asset's status, and the moves statushub allows away from it.
+ *
+ * statushub-ui offers the moves; mediahub's own `TransitionAssetStatus` makes
+ * them (integration standard §3) — the browser never writes to statushub. The
+ * slug being shown travels with the change, so a screen drawn before somebody
+ * else moved this asset on is refused as a conflict instead of overwriting
+ * them.
+ *
+ * Guarded moves are shown (`canRevert`) and statushub decides them: its answer
+ * is per-caller, and mediahub keeps no who-may-revert rule of its own. The
+ * control swallows what `onTransition` throws — error handling is the
+ * consumer's — so the refusal is toasted here.
+ */
+export declare function AssetStatusControl({ assetId, statusSlug, }: AssetStatusControlProps): JSX.Element;
+
+export declare namespace AssetStatusControl {
+    var displayName: string;
+}
+
+export declare interface AssetStatusControlProps {
+    assetId: string;
+    /** The asset's stored status slug — what the viewer is looking at. */
+    statusSlug: string;
+}
+
+export declare interface AssetSummaryInfo {
+    id: string;
+    name: string;
+    assetTypeName: string;
+    statusName: string;
+    statusColor: string;
+    createdAt?: Date;
+}
+
+export declare interface AssetTypeClient {
+    list(workspaceId: string): Promise<AssetTypeInfo[]>;
+    get(id: string): Promise<AssetTypeInfo>;
+    create(params: {
+        workspaceId: string;
+        name: string;
+        slug: string;
+        description: string;
+        allowedMimeTypes: string[];
+        metadataSchema: string;
+    }): Promise<AssetTypeInfo>;
+    update(id: string, patch: {
+        name?: string;
+        description?: string;
+        allowedMimeTypes?: string[];
+        metadataSchema?: string;
+        active?: boolean;
+    }): Promise<AssetTypeInfo>;
+    delete(id: string): Promise<void>;
+}
+
+export declare interface AssetTypeInfo {
+    id: string;
+    workspaceId: string;
+    name: string;
+    slug: string;
+    description: string;
+    allowedMimeTypes: string[];
+    metadataSchema: string;
+    active: boolean;
+}
+
+export declare interface AssetVersionInfo {
+    id: string;
+    versionNumber: number;
+    originalFilename: string;
+    storageKey: string;
+    fileSize: number;
+    mimeType: string;
+    createdBy: string;
+    comment: string;
+    createdAt?: Date;
+}
+
+export declare interface AuthzClient {
+    /** Whether the current user holds toggle/grant authority — Owner of the
+     * resource or admin of its workspace (mediahub ADR-0001) — over the
+     * resource. A denial answers false; other failures reject so callers can
+     * fail closed without hiding real errors. */
+    canManage(resourceType: GrantResourceType, resourceId: string): Promise<boolean>;
+}
+
+export declare const BulkActionBar: React.FC<BulkActionBarProps>;
+
+declare interface BulkActionBarProps {
+}
+
+export declare const CollectionChipField: React.FC<CollectionChipFieldProps>;
+
+declare interface CollectionChipFieldProps {
+    assetId: string;
+    assignedCollectionIds: string[];
+}
+
+export declare interface CollectionClient {
+    list(workspaceId: string): Promise<CollectionInfo[]>;
+    get(id: string): Promise<CollectionInfo>;
+    create(params: {
+        workspaceId: string;
+        name: string;
+        slug: string;
+        description: string;
+        type: CollectionType;
+        rules: string;
+        /** Create as Restricted (creator-only until Grants are issued). @default false */
+        restricted?: boolean;
+    }): Promise<CollectionInfo>;
+    update(id: string, patch: {
+        name?: string;
+        description?: string;
+        rules?: string;
+    }): Promise<CollectionInfo>;
+    delete(id: string): Promise<void>;
+    addAssets(collectionId: string, assetIds: string[]): Promise<void>;
+    removeAssets(collectionId: string, assetIds: string[]): Promise<void>;
+    /** Toggle the Restricted flag (guardian#53). The server refuses with a
+     * leak-guard conflict when the toggle would create a leak state. */
+    setRestricted(id: string, restricted: boolean): Promise<CollectionInfo>;
+}
+
+export declare interface CollectionInfo {
+    id: string;
+    workspaceId: string;
+    name: string;
+    slug: string;
+    description: string;
+    type: CollectionType;
+    rules: string;
+    /** Restricted collections sever Derived Access: only Grants admit anyone. */
+    restricted: boolean;
+}
+
+export declare const CollectionPanel: React.FC<CollectionPanelProps>;
+
+declare interface CollectionPanelProps {
+    activeCollectionId: string;
+    onSelectCollection: (collectionId: string) => void;
+}
+
+export declare function CollectionPicker(props: CollectionPickerProps): React.JSX.Element;
+
+export declare namespace CollectionPicker {
+    var displayName: string;
+}
+
+export declare interface CollectionPickerProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** @default "single" */
+    mode?: "single" | "multi";
+    onSelect: (selection: CollectionSelection) => void;
+    /** Show the inline "New collection" affordance. @default false */
+    allowCreate?: boolean;
+    headerLabel?: string;
+    searchPlaceholder?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    emptyLabel?: string;
+    createLabel?: string;
+}
+
+/** Result of confirming a CollectionPicker selection. */
+export declare type CollectionSelection = {
+    mode: "single";
+    collection: CollectionInfo;
+} | {
+    mode: "multi";
+    collections: CollectionInfo[];
+};
+
+export declare type CollectionType = "unspecified" | "static" | "smart";
+
+export declare interface ConnectAIConnectionServiceClient {
+    listAIConnections(req: any): Promise<{
+        connections: ProtoResponse[];
+    }>;
+    getAIConnection(req: any): Promise<ProtoResponse>;
+    createAIConnection(req: any): Promise<ProtoResponse>;
+    updateAIConnection(req: any): Promise<ProtoResponse>;
+    deleteAIConnection(req: {
+        id: string;
+    }): Promise<unknown>;
+}
+
+export declare interface ConnectAIProcessServiceClient {
+    listAIProcesses(req: any): Promise<{
+        processes: ProtoResponse[];
+    }>;
+    getAIProcess(req: any): Promise<ProtoResponse>;
+    createAIProcess(req: any): Promise<ProtoResponse>;
+    updateAIProcess(req: any): Promise<ProtoResponse>;
+    deleteAIProcess(req: {
+        id: string;
+    }): Promise<unknown>;
+}
+
+export declare interface ConnectAssetServiceClient {
+    listAssets(req: any): Promise<{
+        assets: ProtoResponse[];
+        pagination?: {
+            total: number;
+            page: number;
+            pageSize: number;
+            totalPages: number;
+        };
+    }>;
+    getAsset(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+    createAsset(req: any): Promise<ProtoResponse>;
+    updateAsset(req: any): Promise<ProtoResponse>;
+    deleteAsset(req: {
+        id: string;
+    }): Promise<unknown>;
+    getUploadURL(req: any): Promise<{
+        uploadUrl: string;
+        versionId: string;
+    }>;
+    finalizeUpload(req: {
+        versionId: string;
+    }): Promise<ProtoResponse>;
+    getDownloadURL(req: {
+        assetId: string;
+        versionId: string;
+    }): Promise<{
+        downloadUrl: string;
+    }>;
+    moveAsset(req: {
+        id: string;
+        folderId: string;
+    }): Promise<ProtoResponse>;
+    transitionAssetStatus(req: {
+        id: string;
+        fromStatusSlug: string;
+        toStatusSlug: string;
+    }): Promise<ProtoResponse>;
+    enhanceAssetMetadata(req: {
+        assetId: string;
+    }): Promise<ProtoResponse>;
+    listAIProcessRuns(req: {
+        assetId: string;
+    }): Promise<{
+        runs: ProtoResponse[];
+    }>;
+}
+
+export declare interface ConnectAssetTypeServiceClient {
+    listAssetTypes(req: {
+        workspaceId: string;
+    }): Promise<{
+        assetTypes: ProtoResponse[];
+    }>;
+    getAssetType(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+    createAssetType(req: any): Promise<ProtoResponse>;
+    updateAssetType(req: any): Promise<ProtoResponse>;
+    deleteAssetType(req: {
+        id: string;
+    }): Promise<unknown>;
+}
+
+export declare interface ConnectCollectionServiceClient {
+    listCollections(req: {
+        workspaceId: string;
+    }): Promise<{
+        collections: ProtoResponse[];
+    }>;
+    getCollection(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+    createCollection(req: any): Promise<ProtoResponse>;
+    updateCollection(req: any): Promise<ProtoResponse>;
+    deleteCollection(req: {
+        id: string;
+    }): Promise<unknown>;
+    addAssets(req: {
+        collectionId: string;
+        assetIds: string[];
+    }): Promise<unknown>;
+    removeAssets(req: {
+        collectionId: string;
+        assetIds: string[];
+    }): Promise<unknown>;
+    /** Restricted toggles — land with guardian#53; optional so the package
+     * keeps accepting pre-#53 generated clients. */
+    restrictCollection?(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+    unrestrictCollection?(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+}
+
+export declare interface ConnectDashboardServiceClient {
+    getWorkspaceStats(req: {
+        workspaceId: string;
+    }): Promise<{
+        totalAssets: bigint;
+        totalStorageBytes: bigint;
+        statusCounts: Array<{
+            statusSlug: string;
+            name: string;
+            color: string;
+            behavior: string;
+            count: bigint;
+        }>;
+        recentUploads: Array<{
+            id: string;
+            name: string;
+            assetTypeName: string;
+            statusName: string;
+            statusColor: string;
+            createdAt?: {
+                seconds: bigint;
+                nanos: number;
+            } | undefined;
+        }>;
+    }>;
+    getDashboardLayout(req: {
+        workspaceId: string;
+    }): Promise<{
+        layoutJson: string;
+    }>;
+    saveDashboardLayout(req: {
+        workspaceId: string;
+        layoutJson: string;
+    }): Promise<unknown>;
+}
+
+export declare interface ConnectFolderServiceClient {
+    listFolders(req: {
+        workspaceId: string;
+        parentId: string;
+    }): Promise<{
+        folders: ProtoResponse[];
+    }>;
+    getFolder(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+    createFolder(req: any): Promise<ProtoResponse>;
+    updateFolder(req: {
+        id: string;
+        name: string;
+    }): Promise<ProtoResponse>;
+    deleteFolder(req: {
+        id: string;
+    }): Promise<unknown>;
+    moveFolder(req: {
+        id: string;
+        parentId: string;
+    }): Promise<ProtoResponse>;
+    /** Restricted toggles — land with guardian#53; optional so the package
+     * keeps accepting pre-#53 generated clients. */
+    restrictFolder?(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+    unrestrictFolder?(req: {
+        id: string;
+    }): Promise<ProtoResponse>;
+}
+
+export declare interface ConnectGrantServiceClient {
+    grantAccess(req: {
+        resourceType: number;
+        resourceId: string;
+        userId: string;
+        level: number;
+    }): Promise<unknown>;
+    revokeAccess(req: {
+        resourceType: number;
+        resourceId: string;
+        userId: string;
+    }): Promise<unknown>;
+    listGrants(req: {
+        resourceType: number;
+        resourceId: string;
+    }): Promise<{
+        ownerUserId: string;
+        grants: any[];
+    }>;
+}
+
+export declare interface ConnectTagServiceClient {
+    listTags(req: {
+        workspaceId: string;
+    }): Promise<{
+        tags: ProtoResponse[];
+    }>;
+    createTag(req: any): Promise<ProtoResponse>;
+    updateTag(req: {
+        id: string;
+        name: string;
+    }): Promise<ProtoResponse>;
+    deleteTag(req: {
+        id: string;
+    }): Promise<unknown>;
+    tagAssets(req: {
+        tagId: string;
+        assetIds: string[];
+    }): Promise<unknown>;
+    untagAssets(req: {
+        tagId: string;
+        assetIds: string[];
+    }): Promise<unknown>;
+}
+
+export declare interface ConnectUserServiceClient {
+    resolveUsers(req: {
+        userIds: string[];
+    }): Promise<{
+        users: any[];
+    }>;
+    listWorkspaceMembers(req: {
+        workspaceId: string;
+    }): Promise<{
+        members: any[];
+    }>;
+}
+
+export declare interface CreateAssetParams {
+    name: string;
+    description?: string;
+    assetTypeId: string;
+    folderId?: string;
+    metadata?: Record<string, unknown>;
+    analyzeWithAi?: boolean;
+}
+
+export declare function createConnectAIConnectionClient(c: ConnectAIConnectionServiceClient): AIConnectionClient;
+
+export declare function createConnectAIProcessClient(c: ConnectAIProcessServiceClient): AIProcessClient;
+
+export declare function createConnectAssetClient(c: ConnectAssetServiceClient): AssetClient;
+
+export declare function createConnectAssetTypeClient(c: ConnectAssetTypeServiceClient): AssetTypeClient;
+
+/**
+ * Authority probe (guardian#55): GrantService gates every call — ListGrants
+ * included — on exactly the toggle/grant authority (Owner of the resource or
+ * admin of its workspace, mediahub ADR-0001), so a roster read doubles as the
+ * check. A denial means "not an authority"; other failures reject unchanged.
+ */
+export declare function createConnectAuthzClient(c: ConnectGrantServiceClient): AuthzClient;
+
+export declare function createConnectCollectionClient(c: ConnectCollectionServiceClient): CollectionClient;
+
+export declare function createConnectDashboardClient(c: ConnectDashboardServiceClient): DashboardClient;
+
+export declare function createConnectDirectoryClient(c: ConnectUserServiceClient): DirectoryClient;
+
+export declare function createConnectFolderClient(c: ConnectFolderServiceClient): FolderClient;
+
+export declare function createConnectGrantClient(c: ConnectGrantServiceClient): GrantClient;
+
+export declare function createConnectMediahubClients(gen: {
+    asset: ConnectAssetServiceClient;
+    folder: ConnectFolderServiceClient;
+    collection: ConnectCollectionServiceClient;
+    tag: ConnectTagServiceClient;
+    assetType: ConnectAssetTypeServiceClient;
+    user: ConnectUserServiceClient;
+    grant: ConnectGrantServiceClient;
+    dashboard: ConnectDashboardServiceClient;
+    aiConnection: ConnectAIConnectionServiceClient;
+    aiProcess: ConnectAIProcessServiceClient;
+}): MediahubClients;
+
+export declare function createConnectTagClient(c: ConnectTagServiceClient): TagClient;
+
+export declare interface DashboardClient {
+    getWorkspaceStats(workspaceId: string): Promise<WorkspaceStats>;
+    getDashboardLayout(workspaceId: string): Promise<string>;
+    saveDashboardLayout(workspaceId: string, layoutJson: string): Promise<void>;
+}
+
+/**
+ * Describes an RPC failure for the user. Permission denials and leak-guard
+ * conflicts get mapped copy (never the raw server string); anything else
+ * keeps the server's message under the caller's title, matching the previous
+ * toast behavior.
+ */
+export declare function describeRpcError(err: unknown, fallbackTitle: string): RpcErrorDescription;
+
+export declare interface DirectoryClient {
+    resolveUsers(ids: string[]): Promise<UserInfo[]>;
+    /** Every member of the workspace (union of admins and members), resolved
+     * display names, sorted by name. Backs the grant picker; deliberately
+     * unpaginated — the member set is workspace-bounded. */
+    listWorkspaceMembers(workspaceId: string): Promise<UserInfo[]>;
+}
+
+export declare const FolderBreadcrumbs: React.FC<FolderBreadcrumbsProps>;
+
+declare interface FolderBreadcrumbsProps {
+    folderId: string;
+    onNavigate: (folderId: string) => void;
+}
+
+export declare interface FolderClient {
+    list(workspaceId: string, parentId: string): Promise<FolderInfo[]>;
+    get(id: string): Promise<FolderInfo>;
+    create(params: {
+        workspaceId: string;
+        name: string;
+        slug: string;
+        parentId: string;
+        /** Create as Restricted (creator-only until Grants are issued). @default false */
+        restricted?: boolean;
+    }): Promise<FolderInfo>;
+    update(id: string, name: string): Promise<FolderInfo>;
+    delete(id: string): Promise<void>;
+    move(id: string, parentId: string): Promise<FolderInfo>;
+    /** Toggle the Restricted flag (guardian#53). The server refuses with a
+     * leak-guard conflict when the toggle would create a leak state. */
+    setRestricted(id: string, restricted: boolean): Promise<FolderInfo>;
+}
+
+export declare interface FolderInfo {
+    id: string;
+    workspaceId: string;
+    name: string;
+    slug: string;
+    parentId: string;
+    /** Restricted folders sever Derived Access: only Grants admit anyone. */
+    restricted: boolean;
+}
+
+export declare const FolderTree: React.FC<FolderTreeProps>;
+
+declare interface FolderTreeProps {
+    activeFolderId: string;
+    onFolderSelect: (folderId: string) => void;
+}
+
+export declare interface GetUploadUrlParams {
+    assetId: string;
+    filename: string;
+    contentType: string;
+    fileSize: number;
+    comment?: string;
+}
+
+/** Manages explicit Grants on assets, folders, and collections. Every call —
+ * mutations and roster reads alike — requires owner on the resource or admin
+ * on its workspace; the server answers PermissionDenied otherwise. */
+export declare interface GrantClient {
+    list(resourceType: GrantResourceType, resourceId: string): Promise<GrantRoster>;
+    /** Upserts: a user holds at most one Grant per resource, so granting
+     * replaces any existing Grant at whatever level it had. */
+    grant(resourceType: GrantResourceType, resourceId: string, userId: string, level: GrantLevel): Promise<void>;
+    /** Level-less and idempotent: removes whatever the user held. */
+    revoke(resourceType: GrantResourceType, resourceId: string, userId: string): Promise<void>;
+}
+
+/** One explicit Grant on a roster: a named user holding a grantable level. */
+export declare interface GrantEntry {
+    userId: string;
+    level: GrantLevel;
+}
+
+/** A grantable relation. Ownership is structural and never grantable. */
+export declare type GrantLevel = "viewer" | "editor";
+
+/** The kinds of resource a Grant applies to (guardian#52). */
+export declare type GrantResourceType = "asset" | "folder" | "collection";
+
+/** A resource's roster: the structural Owner plus explicit Grants only —
+ * Derived Access (workspace membership, folder chains, collection
+ * membership) is deliberately absent. */
+export declare interface GrantRoster {
+    /** Empty for resources created before their owner tuples were
+     * backfilled — render no Owner row rather than an empty name. */
+    ownerUserId: string;
+    grants: GrantEntry[];
+}
+
+/**
+ * Thin wrapper around anker's InlineEdit that adds async save with error handling.
+ * On error, the value reverts to the previous value automatically.
+ */
+export declare const InlineEditField: React.FC<InlineEditFieldProps>;
+
+declare interface InlineEditFieldProps {
+    value: string;
+    onSave: (newValue: string) => Promise<void>;
+    as?: "input" | "textarea";
+    placeholder?: string;
+}
+
+export declare const isActive: (runs: AIProcessRunInfo[] | undefined) => boolean;
+
+/** Whether an RPC failure is a Connect permission denial. Callers that probe
+ * for authority (a denial means "not an authority", not "broken") branch on
+ * this instead of re-implementing the structural code check. */
+export declare function isPermissionDenied(err: unknown): boolean;
+
+/**
+ * Whether an RPC failure is "try again in a moment" rather than a verdict.
+ *
+ * The server refuses a status change, and a behavior-filtered listing, with
+ * Unavailable while statushub cannot be reached (statushub integration
+ * standard §6, knkCS/mediahub#120) — the one code that means the same request,
+ * unchanged, will work once the service answers again. mediahub being
+ * unreachable itself arrives as the same code and means the same thing to the
+ * reader, so the two are deliberately not told apart.
+ */
+export declare function isRetryableUnavailable(err: unknown): boolean;
+
+/** One offending asset→collection pair behind a leak-guard refusal. */
+export declare interface LeakGuardExposure {
+    assetId: string;
+    assetName: string;
+    collectionId: string;
+    collectionName: string;
+}
+
+/**
+ * Explains a refused Restricted toggle (guardian#55): the refusing rule in
+ * human copy plus every offending asset→collection pair, each side linked to
+ * its surface when the host registered routes — never a raw error.
+ */
+export declare const LeakGuardRefusalDialog: React.FC<LeakGuardRefusalDialogProps>;
+
+export declare interface LeakGuardRefusalDialogProps {
+    /** The mapped leak-guard failure to explain. Callers keep the last refusal
+     * mounted while the dialog animates closed (same #66 semantics as the
+     * other dialogs) — `null` renders nothing. */
+    refusal: RpcErrorDescription | null;
+    open: boolean;
+    onClose: () => void;
+    closeLabel?: string;
+    /** Line under the pair list telling the user how to proceed. */
+    resolveHint?: string;
+}
+
+/**
+ * "Manage access" panel for assets, folders, and collections (guardian#52):
+ * a pinned Owner row, the roster of Grants with level dropdowns and revoke,
+ * a member picker, and a Derived-Access note. The roster read doubles as the
+ * authority gate — the server answers PermissionDenied to everyone but the
+ * Owner and workspace admins, and those callers get the denial copy instead
+ * of a roster (grantees see content, never who else was granted).
+ */
+export declare function ManageAccessDialog(props: ManageAccessDialogProps): React.JSX.Element;
+
+export declare namespace ManageAccessDialog {
+    var displayName: string;
+}
+
+export declare interface ManageAccessDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    subject: ManageAccessSubject;
+    headerLabel?: string;
+    doneLabel?: string;
+    ownerBadgeLabel?: string;
+    addPersonLabel?: string;
+    grantLabel?: string;
+    viewerLabel?: string;
+    editorLabel?: string;
+    /** Derived-Access note on open content. */
+    openAccessNote?: string;
+    /** Derived-Access note on Restricted content (explicit Grants only). */
+    restrictedAccessNote?: string;
+}
+
+/** What the panel manages access to: the full record is carried so the
+ * Derived-Access note can reason about Restricted chains without refetching
+ * what the mount site already holds. */
+export declare type ManageAccessSubject = {
+    kind: "asset";
+    asset: AssetInfo;
+} | {
+    kind: "folder";
+    folder: FolderInfo;
+} | {
+    kind: "collection";
+    collection: CollectionInfo;
+};
+
+/**
+ * @knkcs/mediahub-ui — reusable mediahub asset-management surfaces.
+ *
+ * Transport-agnostic clients + provider + TanStack Query hooks + stores,
+ * plus the UI surfaces themselves (<AssetLibrary>, <AssetPicker>,
+ * <CollectionPicker>, <AssetDetail>, …). A host's own tests reach the
+ * `./testing` subpath instead of this one — see `src/testing`.
+ */
+export declare const MEDIAHUB_UI_VERSION = "0.1.0";
+
+export declare interface MediahubClients {
+    assets: AssetClient;
+    folders: FolderClient;
+    collections: CollectionClient;
+    tags: TagClient;
+    assetTypes: AssetTypeClient;
+    directory: DirectoryClient;
+    grants: GrantClient;
+    dashboard: DashboardClient;
+    aiConnection: AIConnectionClient;
+    aiProcess: AIProcessClient;
+    authz: AuthzClient;
+}
+
+/** Host-app routes for the places this package can only point at, never
+ * navigate to itself (it has no router dependency). Rendered as plain
+ * anchors; hosts include any basename in the returned href. */
+export declare interface MediahubLinks {
+    /** Route to an asset's detail view. */
+    assetHref?: (assetId: string) => string;
+    /** Route to a collection's view. */
+    collectionHref?: (collectionId: string) => string;
+}
+
+export declare function MediahubProvider({ clients, workspaceId, links, children, }: MediahubProviderProps): JSX.Element;
+
+export declare namespace MediahubProvider {
+    var displayName: string;
+}
+
+export declare interface MediahubProviderProps {
+    clients: MediahubClients;
+    /** Ambient workspace scope — every hook reads it. */
+    workspaceId: string;
+    /** Host routes for cross-surface references (e.g. the leak-guard refusal
+     * dialog's pair links). Omitted routes render as plain text. */
+    links?: MediahubLinks;
+    children: ReactNode;
+}
+
+/**
+ * Destination folder picker for moving a folder or an asset. Destinations
+ * that would trip the server's leak guard (moving exposed content into a
+ * Restricted chain, guardian ADR 0003) render disabled with the reason
+ * inline; the server remains authoritative and re-checks every move.
+ */
+export declare function MoveDialog(props: MoveDialogProps): React.JSX.Element;
+
+export declare namespace MoveDialog {
+    var displayName: string;
+}
+
+export declare interface MoveDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    subject: MoveSubject;
+    /** Called after a successful move with the destination folder id
+     * ("" = workspace root). */
+    onMoved?: (destinationId: string) => void;
+    headerLabel?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    rootLabel?: string;
+    currentLocationLabel?: string;
+    selfLocationLabel?: string;
+    /** Reason shown on leak-guarded destinations. */
+    blockedLabel?: string;
+}
+
+/** What the dialog moves: a folder (from the tree's context menu) or an
+ * asset (from its detail view). */
+export declare type MoveSubject = {
+    kind: "folder";
+    folder: FolderInfo;
+} | {
+    kind: "asset";
+    asset: AssetInfo;
+};
+
+export declare interface Page<T> {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+}
+
+declare interface PreferencesActions {
+    toggleSidebar: () => void;
+    setViewMode: (mode: "list" | "grid") => void;
+}
+
+declare interface PreferencesState {
+    sidebarCollapsed: boolean;
+    viewMode: "list" | "grid";
+}
+
+declare type PreferencesStore = PreferencesState & PreferencesActions;
+
+declare type ProtoResponse = {
+    [key: string]: any;
+};
+
+/** The shared Restricted-container warning (guardian#48): shown when creating
+ * a Restricted folder and, with the other noun, on the collection dialog's
+ * Restricted switch. */
+export declare function restrictedContainerWarning(kind: "folder" | "collection"): string;
+
+/** Deliberate-path dialog for creating a Restricted folder. The everyday
+ * inline "New Folder" input stays the fast path for ordinary folders. */
+export declare const RestrictedFolderDialog: React.FC<RestrictedFolderDialogProps>;
+
+export declare interface RestrictedFolderDialogProps {
+    open: boolean;
+    onClose: () => void;
+    /** Parent folder to create under; "" creates at the root. */
+    parentId: string;
+    /** Called after a successful create (e.g. to refresh the tree). */
+    onCreated?: () => void;
+}
+
+/** Lock marker rendered wherever a Restricted container appears. The
+ * `aria-label="Restricted"` is the contract tests target — keep it stable. */
+export declare const RestrictedLockBadge: React.FC<RestrictedLockBadgeProps>;
+
+export declare interface RestrictedLockBadgeProps {
+    /** Icon size in px. @default 12 */
+    size?: number;
+    /** Optional left margin (spacing token) for sites without a gap parent. */
+    ml?: number;
+}
+
+/** Warning banner for the deliberate create-Restricted paths. */
+export declare const RestrictedWarningNotice: React.FC<RestrictedWarningNoticeProps>;
+
+export declare interface RestrictedWarningNoticeProps {
+    kind: "folder" | "collection";
+}
+
+export declare interface RpcErrorDescription {
+    kind: "permission-denied" | "leak-guard" | "other";
+    title: string;
+    description: string;
+    /** Present for leak-guard conflicts: the items the refusal involves. */
+    exposures?: LeakGuardExposure[];
+    /** Present for leak-guard conflicts: the refusing rule's explanation
+     * without the joined item list — for surfaces that render `exposures`
+     * themselves (e.g. the refusal dialog). */
+    ruleText?: string;
+}
+
+declare interface SelectionActions {
+    toggle: (id: string) => void;
+    selectAll: (ids: string[]) => void;
+    setSelection: (ids: string[]) => void;
+    selectRange: (targetId: string, orderedIds: string[]) => void;
+    clearSelection: () => void;
+}
+
+declare interface SelectionState {
+    selectedIds: string[];
+    lastClickedId: string | null;
+}
+
+declare type SelectionStore = SelectionState & SelectionActions;
+
+/**
+ * The app-wide error toast: maps the failure with describeRpcError and shows
+ * it. `fallbackTitle` is used only for errors outside the two mapped
+ * families, preserving each call site's existing title.
+ */
+export declare function showRpcErrorToast(err: unknown, fallbackTitle: string): void;
+
+export declare interface StatusCountInfo {
+    statusSlug: string;
+    name: string;
+    color: string;
+    behavior: string;
+    count: number;
+}
+
+export declare const TagChipField: React.FC<TagChipFieldProps>;
+
+declare interface TagChipFieldProps {
+    assetId: string;
+    assignedTagIds: string[];
+}
+
+export declare interface TagClient {
+    list(workspaceId: string): Promise<TagInfo[]>;
+    create(params: {
+        workspaceId: string;
+        name: string;
+        slug: string;
+    }): Promise<TagInfo>;
+    update(id: string, name: string): Promise<TagInfo>;
+    delete(id: string): Promise<void>;
+    tagAssets(tagId: string, assetIds: string[]): Promise<void>;
+    untagAssets(tagId: string, assetIds: string[]): Promise<void>;
+}
+
+export declare interface TagInfo {
+    id: string;
+    workspaceId: string;
+    name: string;
+    slug: string;
+}
+
+export declare const TagPanel: React.FC<TagPanelProps>;
+
+declare interface TagPanelProps {
+    activeTags: string[];
+    onToggleTag: (tagId: string) => void;
+}
+
+/** The explicit unrestrict disclosure (guardian#55): spelled out before the
+ * toggle because it widens the audience to the whole workspace. */
+export declare function unrestrictDisclosure(kind: "folder" | "collection", name: string): string;
+
+declare interface UploadActions {
+    addFiles: (files: File[]) => void;
+    setAssetType: (clientId: string, assetTypeId: string) => void;
+    setBatchAssetType: (assetTypeId: string) => void;
+    setAnalyzeWithAi: (v: boolean) => void;
+    startUpload: (workspaceId: string, folderId?: string) => void;
+    setQueryClient: (qc: QueryClient) => void;
+    setAssetClient: (client: AssetClient) => void;
+    clearPending: () => void;
+    dismiss: () => void;
+    toggleExpanded: () => void;
+}
+
+export declare const UploadDialog: React.FC<UploadDialogProps>;
+
+declare interface UploadDialogProps {
+    open: boolean;
+    onClose: () => void;
+    folderId?: string;
+}
+
+export declare const UploadDropZone: React.FC<UploadDropZoneProps>;
+
+declare interface UploadDropZoneProps {
+    onFilesSelected: (files: File[]) => void;
+    compact?: boolean;
+}
+
+export declare interface UploadFile {
+    clientId: string;
+    file: File;
+    assetTypeId: string;
+    status: "pending" | "creating" | "uploading" | "finalizing" | "done" | "error";
+    progress: number;
+    error?: string;
+    assetId?: string;
+    versionId?: string;
+}
+
+declare interface UploadState {
+    files: UploadFile[];
+    visible: boolean;
+    expanded: boolean;
+    analyzeWithAi: boolean;
+    queryClient: QueryClient | null;
+    assetClient: AssetClient | null;
+}
+
+declare type UploadStore = UploadState & UploadActions;
+
+export declare interface UploadTarget {
+    uploadUrl: string;
+    versionId: string;
+}
+
+export declare const UploadToastStack: React.FC;
+
+export declare function useAddAssetsToCollection(): UseMutationResult<void, Error, {
+collectionId: string;
+assetIds: string[];
+}, unknown>;
+
+export declare function useAddVersion(): {
+    progress: number;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: UseMutateFunction<AssetInfo, Error, AddVersionVars, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<AssetInfo, Error, AddVersionVars, unknown>;
+} | {
+    progress: number;
+    data: undefined;
+    variables: AddVersionVars;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: UseMutateFunction<AssetInfo, Error, AddVersionVars, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<AssetInfo, Error, AddVersionVars, unknown>;
+} | {
+    progress: number;
+    data: undefined;
+    error: Error;
+    variables: AddVersionVars;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: UseMutateFunction<AssetInfo, Error, AddVersionVars, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<AssetInfo, Error, AddVersionVars, unknown>;
+} | {
+    progress: number;
+    data: AssetInfo;
+    error: null;
+    variables: AddVersionVars;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: UseMutateFunction<AssetInfo, Error, AddVersionVars, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: UseMutateAsyncFunction<AssetInfo, Error, AddVersionVars, unknown>;
+};
+
+export declare function useAIConnection(id: string): UseQueryResult<AIConnectionInfo, Error>;
+
+export declare function useAIConnections(): UseQueryResult<AIConnectionInfo[], Error>;
+
+export declare function useAIProcess(id: string): UseQueryResult<AIProcessInfo, Error>;
+
+export declare function useAIProcesses(assetTypeId: string): UseQueryResult<AIProcessInfo[], Error>;
+
+export declare function useAIProcessRuns(assetId: string): UseQueryResult<AIProcessRunInfo[], Error>;
+
+export declare function useAsset(id: string): UseQueryResult<AssetInfo, Error>;
+
+export declare function useAssets(filters?: AssetFilters): UseQueryResult<Page<AssetInfo>, Error>;
+
+/**
+ * The status a slug names.
+ *
+ * `isLoading` is reported separately on purpose: "not answered yet" and
+ * "answered, and this slug is not in the catalogue" look the same in the data
+ * and mean opposite things. Collapsing them makes every list paint its raw
+ * slugs for one frame before the names arrive.
+ *
+ * Once the catalogue has answered, a missing status is an **unknown status** —
+ * the slug was deleted, or statushub had never answered at birth (§5) — and
+ * callers render the raw slug rather than nothing: the asset still has a
+ * status, mediahub just cannot name it.
+ */
+export declare function useAssetStatus(slug: string): {
+    status: StatusInfo | undefined;
+    isLoading: boolean;
+};
+
+/** The asset catalogue's statuses in the viewer's workspace. */
+export declare function useAssetStatuses(): UseQueryResult<NoInfer<StatusInfo[]>, Error>;
+
+export declare function useAssetType(id: string): UseQueryResult<AssetTypeInfo, Error>;
+
+export declare function useAssetTypes(): UseQueryResult<AssetTypeInfo[], Error>;
+
+/**
+ * Whether the current user may manage a resource — toggle its Restricted
+ * flag, grant or revoke access (Owner of the resource or admin of its
+ * workspace, mediahub ADR-0001). Consumers read `data === true`; a pending or
+ * failed probe hides authority-only actions (fail closed).
+ */
+export declare function useCanManage(resourceType: GrantResourceType, resourceId: string): UseQueryResult<boolean, Error>;
+
+export declare function useCollection(id: string): UseQueryResult<CollectionInfo, Error>;
+
+export declare function useCollections(): UseQueryResult<CollectionInfo[], Error>;
+
+export declare function useCreateAIConnection(): UseMutationResult<AIConnectionInfo, Error, {
+name: string;
+provider: string;
+endpoint: string;
+deployment: string;
+apiVersion: string;
+baseUrl: string;
+model: string;
+apiKey: string;
+description: string;
+}, unknown>;
+
+export declare function useCreateAIProcess(): UseMutationResult<AIProcessInfo, Error, {
+assetTypeId: string;
+connectionId: string;
+name: string;
+prompt: string;
+outputs: {
+key: string;
+target: string;
+metadataAccessor: string;
+}[];
+position: number;
+workspaceId: string;
+}, unknown>;
+
+export declare function useCreateAsset(): UseMutationResult<AssetInfo, Error, CreateAssetParams, unknown>;
+
+export declare function useCreateAssetType(): UseMutationResult<AssetTypeInfo, Error, {
+name: string;
+slug: string;
+description: string;
+allowedMimeTypes: string[];
+metadataSchema: string;
+}, unknown>;
+
+export declare function useCreateCollection(): UseMutationResult<CollectionInfo, Error, {
+name: string;
+slug: string;
+description: string;
+type: CollectionType;
+rules: string;
+restricted?: boolean;
+}, unknown>;
+
+export declare function useCreateFolder(): UseMutationResult<FolderInfo, Error, {
+name: string;
+slug: string;
+parentId: string;
+restricted?: boolean;
+}, unknown>;
+
+export declare function useCreateTag(): UseMutationResult<TagInfo, Error, {
+name: string;
+slug: string;
+}, unknown>;
+
+export declare function useDeleteAIConnection(): UseMutationResult<void, Error, string, unknown>;
+
+export declare function useDeleteAIProcess(): UseMutationResult<void, Error, string, unknown>;
+
+export declare function useDeleteAsset(): UseMutationResult<void, Error, string, unknown>;
+
+export declare function useDeleteAssetType(): UseMutationResult<void, Error, string, unknown>;
+
+export declare function useDeleteCollection(): UseMutationResult<void, Error, string, unknown>;
+
+export declare function useDeleteFolder(): UseMutationResult<void, Error, string, unknown>;
+
+export declare function useDeleteTag(): UseMutationResult<void, Error, string, unknown>;
+
+export declare function useEnhanceAssetMetadata(): UseMutationResult<AssetInfo, Error, string, unknown>;
+
+export declare function useFolder(id: string): UseQueryResult<FolderInfo, Error>;
+
+export declare function useFolders(parentId?: string, opts?: {
+    enabled?: boolean;
+}): UseQueryResult<FolderInfo[], Error>;
+
+export declare function useGetDashboardLayout(): UseQueryResult<string, Error>;
+
+export declare function useGrantAccess(): UseMutationResult<void, Error, {
+resourceType: GrantResourceType;
+resourceId: string;
+userId: string;
+level: GrantLevel;
+}, unknown>;
+
+/**
+ * The roster read doubles as the sharing panel's authority gate: the server
+ * answers PermissionDenied for everyone but the resource's Owner and
+ * workspace admins, and that denial is a final answer — never retried.
+ */
+export declare function useGrants(resourceType: GrantResourceType, resourceId: string, opts?: {
+    enabled?: boolean;
+}): UseQueryResult<GrantRoster, Error>;
+
+export declare function useMediahubClients(): MediahubClients;
+
+/** Host-supplied routes. Empty object when the host didn't pass `links` to
+ * `<MediahubProvider>` — consumers degrade to plain text. */
+export declare function useMediahubLinks(): MediahubLinks;
+
+export declare function useMoveAsset(): UseMutationResult<AssetInfo, Error, {
+id: string;
+folderId: string;
+}, unknown>;
+
+export declare function useMoveFolder(): UseMutationResult<FolderInfo, Error, {
+id: string;
+parentId: string;
+}, unknown>;
+
+export declare const usePreferencesStore: UseBoundStore<Omit<StoreApi<PreferencesStore>, "setState" | "persist"> & {
+setState(partial: PreferencesStore | Partial<PreferencesStore> | ((state: PreferencesStore) => PreferencesStore | Partial<PreferencesStore>), replace?: false | undefined): unknown;
+setState(state: PreferencesStore | ((state: PreferencesStore) => PreferencesStore), replace: true): unknown;
+persist: {
+setOptions: (options: Partial<PersistOptions<PreferencesStore, PreferencesStore, unknown>>) => void;
+clearStorage: () => void;
+rehydrate: () => Promise<void> | void;
+hasHydrated: () => boolean;
+onHydrate: (fn: (state: PreferencesStore) => void) => () => void;
+onFinishHydration: (fn: (state: PreferencesStore) => void) => () => void;
+getOptions: () => Partial<PersistOptions<PreferencesStore, PreferencesStore, unknown>>;
+};
+}>;
+
+export declare function usePreviewURL(assetId: string, versionId: string): UseQueryResult<string, Error>;
+
+export declare function useRemoveAssetsFromCollection(): UseMutationResult<void, Error, {
+collectionId: string;
+assetIds: string[];
+}, unknown>;
+
+export declare function useRevokeAccess(): UseMutationResult<void, Error, {
+resourceType: GrantResourceType;
+resourceId: string;
+userId: string;
+}, unknown>;
+
+export declare interface UserInfo {
+    id: string;
+    displayName: string;
+}
+
+export declare function useSaveDashboardLayout(): UseMutationResult<void, Error, string, unknown>;
+
+export declare const useSelectionStore: UseBoundStore<StoreApi<SelectionStore>>;
+
+export declare function useSetCollectionRestricted(): UseMutationResult<CollectionInfo, Error, {
+id: string;
+restricted: boolean;
+}, unknown>;
+
+export declare function useSetFolderRestricted(): UseMutationResult<FolderInfo, Error, {
+id: string;
+restricted: boolean;
+}, unknown>;
+
+export declare function useTagAssets(): UseMutationResult<void, Error, {
+tagId: string;
+assetIds: string[];
+}, unknown>;
+
+export declare function useTags(): UseQueryResult<TagInfo[], Error>;
+
+export declare function useTransitionAssetStatus(): UseMutationResult<AssetInfo, Error, {
+id: string;
+/** The slug the caller last saw — the change is made against it. */
+fromStatusSlug: string;
+toStatusSlug: string;
+}, unknown>;
+
+export declare function useUntagAssets(): UseMutationResult<void, Error, {
+tagId: string;
+assetIds: string[];
+}, unknown>;
+
+export declare function useUpdateAIConnection(): UseMutationResult<AIConnectionInfo, Error, {
+id: string;
+patch: {
+name?: string;
+endpoint?: string;
+deployment?: string;
+apiVersion?: string;
+baseUrl?: string;
+model?: string;
+apiKey?: string;
+description?: string;
+active?: boolean;
+};
+}, unknown>;
+
+export declare function useUpdateAIProcess(): UseMutationResult<AIProcessInfo, Error, {
+id: string;
+patch: {
+connectionId?: string;
+name?: string;
+prompt?: string;
+outputs?: {
+key: string;
+target: string;
+metadataAccessor: string;
+}[];
+position?: number;
+active?: boolean;
+};
+}, unknown>;
+
+export declare function useUpdateAsset(): UseMutationResult<AssetInfo, Error, {
+id: string;
+patch: {
+name?: string;
+description?: string;
+metadata?: Record<string, unknown>;
+};
+}, unknown>;
+
+export declare function useUpdateAssetType(): UseMutationResult<AssetTypeInfo, Error, {
+id: string;
+patch: {
+name?: string;
+description?: string;
+allowedMimeTypes?: string[];
+metadataSchema?: string;
+active?: boolean;
+};
+}, unknown>;
+
+export declare function useUpdateCollection(): UseMutationResult<CollectionInfo, Error, {
+id: string;
+patch: {
+name?: string;
+description?: string;
+rules?: string;
+};
+}, unknown>;
+
+export declare function useUpdateFolder(): UseMutationResult<FolderInfo, Error, {
+id: string;
+name: string;
+}, unknown>;
+
+export declare function useUpdateTag(): UseMutationResult<TagInfo, Error, {
+id: string;
+name: string;
+}, unknown>;
+
+export declare const useUploadStore: UseBoundStore<StoreApi<UploadStore>>;
+
+export declare function useUsers(ids: string[]): UseQueryResult<Record<string, string>, Error>;
+
+export declare function useWorkspaceId(): string;
+
+/** The active workspace's member listing — backs the grant picker
+ * (guardian#52). Server-sorted by display name; unpaginated by design. */
+export declare function useWorkspaceMembers(opts?: {
+    enabled?: boolean;
+}): UseQueryResult<UserInfo[], Error>;
+
+export declare function useWorkspaceStats(): UseQueryResult<WorkspaceStats, Error>;
+
+export declare interface WorkspaceStats {
+    totalAssets: number;
+    totalStorageBytes: number;
+    statusCounts: StatusCountInfo[];
+    recentUploads: AssetSummaryInfo[];
+}
+
+export { }