@memberjunction/ng-dashboards 5.23.0 → 5.24.0

package/dist/AI/components/autotagging/autotagging-pipeline-resource.component.d.ts

@@ -9,10 +9,11 @@
 import { OnDestroy, AfterViewInit } from '@angular/core';
 import { CompositeKey } from '@memberjunction/core';
 import { TreeBranchConfig, TreeLeafConfig } from '@memberjunction/ng-trees';
-import { ResourceData } from '@memberjunction/core-entities';
+import { ResourceData, MJContentSourceTypeEntity_IContentSourceTypeField } from '@memberjunction/core-entities';
 import { BaseResourceComponent } from '@memberjunction/ng-shared';
+import { WordCloudItem } from '@memberjunction/ng-word-cloud';
 import * as i0 from "@angular/core";
-type TabName = 'pipeline' | 'sources' | 'types' | 'tags' | 'history';
+type TabName = 'pipeline' | 'sources' | 'types' | 'tags' | 'taxonomy' | 'history';
 interface NavItem {
     Tab: TabName;
     Icon: string;
@@ -66,6 +67,15 @@ interface SourceCard {
     ContentFileTypeID: string;
     EmbeddingModelID: string;
     VectorIndexID: string;
+    EntityID: string;
+    EntityDocumentID: string;
+    RequiresFileType: boolean;
+    /** FK to ScheduledAction entity, null if no schedule configured */
+    ScheduledActionID: string | null;
+    /** Denormalized name of the linked ScheduledAction */
+    ScheduledActionName: string | null;
+    /** Human-readable schedule description (parsed from cron) */
+    ScheduleDescription: string | null;
 }
 interface ContentTypeCard {
     ID: string;
@@ -115,6 +125,100 @@ interface DropdownOption {
     ID: string;
     Name: string;
 }
+/** G3: Content item duplicate pair for review */
+interface ContentDuplicateRow {
+    ID: string;
+    ItemAName: string;
+    ItemASource: string;
+    ItemBName: string;
+    ItemBSource: string;
+    SimilarityScore: number;
+    DetectionMethod: string;
+    Status: 'Pending' | 'Confirmed' | 'Dismissed' | 'Merged';
+}
+/** D2/D3/D8: Per-source detail row for a specific pipeline run */
+interface RunDetailRow {
+    SourceName: string;
+    SourceType: string;
+    Status: string;
+    StatusClass: string;
+    ItemsProcessed: number;
+    ItemsTagged: number;
+    ItemsVectorized: number;
+    ErrorCount: number;
+    TotalTokens: number;
+    TotalCost: number;
+    Duration: string;
+}
+type TaxonomySubTab = 'tree' | 'duplicates' | 'orphans' | 'treemap' | 'audit';
+interface TaxTreeNode {
+    ID: string;
+    Name: string;
+    DisplayName: string;
+    Description: string;
+    ParentID: string | null;
+    Depth: number;
+    Children: TaxTreeNode[];
+    ItemCount: number;
+    AvgWeight: number;
+    HealthColor: 'green' | 'yellow' | 'red';
+    IsExpanded: boolean;
+    IsSelected: boolean;
+    FirstSeen: string;
+}
+interface TaxDuplicatePair {
+    TagA: string;
+    TagB: string;
+    TagAID: string;
+    TagBID: string;
+    Similarity: number;
+    SeverityClass: 'high' | 'moderate';
+    /** True when multiple Tag records share the same name (case-insensitive) */
+    IsExactDuplicate: boolean;
+    /** How many Tag records share this exact name (only set when IsExactDuplicate) */
+    ExactDuplicateCount: number;
+    /** All Tag IDs sharing the exact name (only set when IsExactDuplicate) */
+    AllIDs: string[];
+}
+interface TaxOrphanCard {
+    ID: string;
+    Name: string;
+    UsageCount: number;
+    AvgWeight: number;
+    FirstSeen: string;
+    LastSeen: string;
+    IsSelected: boolean;
+}
+interface TaxTreemapCell {
+    ID: string;
+    Name: string;
+    ItemCount: number;
+    ColorClass: string;
+    RowSpan: number;
+}
+/** Supported audit action types — matches DB Action values (lowercased) */
+type TaxAuditAction = 'created' | 'merged' | 'moved' | 'deleted' | 'renamed' | 'deprecated' | 'descriptionchanged' | 'reactivated' | 'split';
+interface TaxAuditEvent {
+    Type: TaxAuditAction;
+    Description: string;
+    TagRef: string;
+    User: string;
+    Timestamp: string;
+    DayHeader: string;
+}
+interface TaxHealthStat {
+    Total: number;
+    Healthy: number;
+    NeedAttention: number;
+    Orphaned: number;
+    Duplicates: number;
+}
+interface WeightedTag {
+    Tag: string;
+    Weight: number;
+}
+/** Status value for embedding or tagging pipeline phases */
+type ItemPipelineStatus = 'Complete' | 'Processing' | 'Failed' | 'Pending';
 interface ContentItemDetail {
     ID: string;
     Name: string;
@@ -125,12 +229,23 @@ interface ContentItemDetail {
     URL: string;
     TextContent: string;
     Checksum: string;
-    Tags: string[];
+    Tags: WeightedTag[];
     CreatedAt: string;
     UpdatedAt: string;
     ContentSourceID: string;
+    ContentSourceTypeID: string;
     StatusDot: 'complete' | 'processing' | 'error';
     TagCount: number;
+    /** Whether this source type uses content/file type (false for Entity sources) */
+    RequiresContentType: boolean;
+    /** Entity record ID if source is entity type (for direct entity navigation) */
+    EntityRecordID: string | null;
+    /** Entity name if source is entity type */
+    EntityName: string | null;
+    /** Embedding pipeline status for this content item */
+    EmbeddingStatus: ItemPipelineStatus;
+    /** Tagging pipeline status for this content item */
+    TaggingStatus: ItemPipelineStatus;
 }
 interface SourceDetailInfo {
     ID: string;
@@ -138,6 +253,7 @@ interface SourceDetailInfo {
     SourceTypeName: string;
     FileTypeName: string;
     ContentTypeName: string;
+    RequiresFileType: boolean;
     StatusClass: 'active' | 'error' | 'inactive';
     StatusLabel: string;
     Icon: string;
@@ -166,22 +282,137 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     FeedItems: FeedItem[];
     SourceMinis: SourceMini[];
     TrendingTags: TagCloudItem[];
+    FeedSearchQuery: string;
+    FeedPage: number;
+    readonly FeedPageSize = 20;
+    /** Sort order for the feed: 'newest' (default) or 'oldest' */
+    FeedSortOrder: 'newest' | 'oldest';
+    /** Feed items filtered by search query and sorted */
+    get FilteredFeedItems(): FeedItem[];
+    /** Toggle feed sort order */
+    ToggleFeedSort(): void;
+    /** Paginated feed items for the current page */
+    get PaginatedFeedItems(): FeedItem[];
+    /** Total pages for the feed */
+    get FeedTotalPages(): number;
+    /** Handle feed search input change */
+    OnFeedSearchChange(): void;
+    /** Navigate to previous feed page */
+    FeedPrevPage(): void;
+    /** Navigate to next feed page */
+    FeedNextPage(): void;
+    /** Get the index in the original FeedItems array for a paginated item */
+    GetFeedItemOriginalIndex(item: FeedItem): number;
     IsRunning: boolean;
+    IsPaused: boolean;
     RunProgress: number;
     RunStage: string;
     RunCurrentItem: string;
+    /** The current pipeline run ID (from GraphQL subscription) */
+    CurrentPipelineRunID: string | null;
+    /** The process run ID (server-side ContentProcessRun) for pause/cancel/resume */
+    CurrentProcessRunID: string | null;
+    ShowPipelineConfig: boolean;
+    PipelineConfig: {
+        Pipeline?: {
+            BatchSize?: number;
+            MaxConcurrentBatches?: number;
+            DelayBetweenBatchesMs?: number;
+            ResumeFromLastBatch?: boolean;
+            ErrorThresholdPercent?: number;
+        };
+        RateLimits?: {
+            LLM?: {
+                RequestsPerMinute?: number;
+                TokensPerMinute?: number;
+            };
+            Embedding?: {
+                RequestsPerMinute?: number;
+                TokensPerMinute?: number;
+            };
+            VectorDB?: {
+                RequestsPerMinute?: number;
+            };
+        };
+    };
+    TogglePipelineConfig(): void;
+    private persistClassifyPreferences;
+    private loadClassifyPreferences;
+    FormatTokenCount(tokens: number): string;
     SourceCards: SourceCard[];
+    ContentDuplicates: ContentDuplicateRow[];
+    IsLoadingDuplicates: boolean;
     ContentTypeCards: ContentTypeCard[];
     TagRows: TagRow[];
     TagCloud: TagCloudItem[];
+    TagCloudWordItems: WordCloudItem[];
     TagsBySource: TagBySource[];
     TagSearchQuery: string;
     FilteredTagRows: TagRow[];
+    SelectedDrillDownTag: string | null;
+    TagDrillDownItems: {
+        ID: string;
+        Name: string;
+        SourceName: string;
+        Weight: number;
+        UpdatedAt: string;
+        FeedIndex: number;
+    }[];
     RunHistoryRows: RunHistoryRow[];
     HistorySourceFilter: string;
     HistoryStatusFilter: string;
     FilteredRunRows: RunHistoryRow[];
     HistorySourceOptions: string[];
+    SelectedRunID: string | null;
+    RunDetailRows: RunDetailRow[];
+    IsLoadingRunDetail: boolean;
+    LiveRunDetailRows: RunDetailRow[];
+    IsLoadingLiveDetails: boolean;
+    TaxSubTab: TaxonomySubTab;
+    TaxTreeNodes: TaxTreeNode[];
+    TaxFlatNodes: TaxTreeNode[];
+    TaxFilteredNodes: TaxTreeNode[];
+    TaxSelectedNode: TaxTreeNode | null;
+    TaxTreeSearch: string;
+    TaxDuplicates: TaxDuplicatePair[];
+    TaxOrphans: TaxOrphanCard[];
+    TaxAllOrphansSelected: boolean;
+    TaxTreemapCells: TaxTreemapCell[];
+    TaxAuditEvents: TaxAuditEvent[];
+    TaxAuditFilterTypes: Set<string>;
+    TaxHealth: TaxHealthStat;
+    TaxRecentItems: {
+        Name: string;
+        Weight: number;
+        Date: string;
+        Icon: string;
+    }[];
+    TaxTreemapKPIs: {
+        Label: string;
+        Value: string;
+    }[];
+    TaxIsEditing: boolean;
+    ShowCreateTagDialog: boolean;
+    CreateTagName: string;
+    CreateTagDescription: string;
+    CreateTagParentID: string | null;
+    /** Label shown in the create dialog to indicate context (e.g., "under AI Agent") */
+    CreateTagParentLabel: string;
+    TaxMultiSelectMode: boolean;
+    TaxSelectedIDs: Set<string>;
+    /** The node currently being dragged over (drop target highlight) */
+    TaxDragOverNodeID: string | null;
+    /** True while a drag-reparent operation is saving */
+    TaxTreeSaving: boolean;
+    /** Count of high-confidence duplicate pairs (>85% similarity) */
+    get TaxHighConfidenceDupeCount(): number;
+    /** Count of moderate-confidence duplicate pairs (70-85% similarity) */
+    get TaxModerateDupeCount(): number;
+    TaxEditName: string;
+    TaxEditDescription: string;
+    private tagsRaw;
+    private taggedItemsRaw;
+    private tagAuditLogsRaw;
     FormMode: FormMode;
     FormSaving: boolean;
     FormSourceName: string;
@@ -198,13 +429,122 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     EditingTypeID: string;
     FormTypeEmbeddingModelID: string;
     FormTypeVectorIndexID: string;
+    FormSourceEntityID: string;
+    FormSourceEntityDocID: string;
     FormSourceEmbeddingModelID: string;
     FormSourceVectorIndexID: string;
+    /** Whether the schedule creation dialog is visible */
+    ShowScheduleDialog: boolean;
+    /** Whether a schedule save operation is in progress */
+    ScheduleSaving: boolean;
+    /** Source card currently being scheduled */
+    SchedulingSourceCard: SourceCard | null;
+    /** Cron expression for the schedule form */
+    ScheduleCron: string;
+    /** Whether the schedule should be active immediately */
+    ScheduleEnabled: boolean;
+    /** Whether a generic confirmation overlay is visible */
+    ShowConfirmDialog: boolean;
+    /** Title text for the confirmation dialog */
+    ConfirmDialogTitle: string;
+    /** Body message for the confirmation dialog */
+    ConfirmDialogMessage: string;
+    /** Callback invoked when user confirms */
+    private confirmDialogAction;
+    /** Whether the split-tag dialog is visible */
+    ShowSplitDialog: boolean;
+    /** Comma-separated new child tag names for the split operation */
+    SplitChildNames: string;
+    /** The node currently being split */
+    private splitTargetNode;
+    /** Whether the move-tag dialog is visible */
+    ShowMoveDialog: boolean;
+    /** Selected new parent tag ID for the move operation */
+    MoveNewParentID: string | null;
+    /** The node currently being moved */
+    private moveTargetNode;
+    /** Whether the treemap drill-in panel is visible */
+    ShowTreemapDrillIn: boolean;
+    /** Tag node currently displayed in treemap drill-in */
+    TreemapDrillInNode: TaxTreeNode | null;
+    /** Cached ScheduledAction entities, keyed by normalized ID */
+    private scheduledActionsCache;
+    /**
+     * Whether the currently selected source type is "Entity", which switches
+     * the URL field to Entity/EntityDocument pickers.
+     */
+    /** Whether the selected source type is the Entity type (name-based check) */
+    get IsEntitySourceTypeSelected(): boolean;
+    /** Whether the selected source type requires Content Type / File Type selection */
+    get SelectedSourceTypeRequiresContentType(): boolean;
+    /** Entities that have at least one EntityDocument configured */
+    get EntitiesWithDocuments(): {
+        ID: string;
+        Name: string;
+    }[];
+    /** Entity documents for the selected entity */
+    get EntityDocOptionsForSelectedEntity(): {
+        ID: string;
+        Name: string;
+    }[];
+    /** Stores source-type-specific config values keyed by RequiredFields[].Key */
+    FormSourceSpecificConfig: Record<string, string>;
+    /** Available MJ Storage provider keys for the storage-provider-picker widget */
+    StorageProviderOptions: string[];
+    /**
+     * The RequiredFields array from the selected source type's ConfigurationObject.
+     * Drives dynamic form rendering — each field becomes a widget.
+     */
+    get SelectedSourceTypeFields(): MJContentSourceTypeEntity_IContentSourceTypeField[];
+    /**
+     * Get dependent options for a field (e.g., entity-doc-picker depends on entity-picker).
+     * Returns entity documents for the entity selected in the dependent field.
+     */
+    GetDependentOptions(field: MJContentSourceTypeEntity_IContentSourceTypeField): {
+        ID: string;
+        Name: string;
+    }[];
+    /**
+     * Handle a source-specific field value change.
+     * For entity-picker: auto-select the first entity doc if only one exists.
+     */
+    OnSourceFieldChanged(fieldKey: string): void;
     SelectedFeedItem: ContentItemDetail | null;
     ShowItemDetail: boolean;
     SelectedSource: SourceDetailInfo | null;
     ShowSourceDetail: boolean;
     SourceDetailLoading: boolean;
+    /** Filter content items in source detail by pipeline status */
+    SourceDetailStatusFilter: ItemPipelineStatus | 'All';
+    /** Available status options for the filter dropdown */
+    readonly SourceDetailStatusOptions: (ItemPipelineStatus | 'All')[];
+    /** Current page index (0-based) for source detail content list */
+    SourceDetailPage: number;
+    /** Number of content items per page in source detail */
+    readonly SourceDetailPageSize = 10;
+    /**
+     * Returns source detail content items filtered by SourceDetailStatusFilter,
+     * then sliced to the current page.
+     */
+    get FilteredSourceDetailItems(): ContentItemDetail[];
+    /** Total number of filtered items (before pagination) */
+    get FilteredSourceDetailTotal(): number;
+    /** Total pages for source detail pagination */
+    get SourceDetailTotalPages(): number;
+    /** Navigate to the previous page in source detail content list */
+    SourceDetailPrevPage(): void;
+    /** Navigate to the next page in source detail content list */
+    SourceDetailNextPage(): void;
+    /** Handle change of the source detail status filter dropdown */
+    OnSourceDetailStatusFilterChange(): void;
+    /**
+     * D4: Placeholder handler for retrying failed items in source detail.
+     * Re-runs the pipeline for the current source. In the future this could
+     * target only Failed items.
+     */
+    RetryFailedItems(): void;
+    /** Returns the CSS class for a pipeline status badge color */
+    GetStatusBadgeClass(status: ItemPipelineStatus): string;
     SourceTypeOptions: DropdownOption[];
     ContentTypeOptions: DropdownOption[];
     FileTypeOptions: DropdownOption[];
@@ -222,8 +562,23 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     private contentTypesRaw;
     private contentFileTypesRaw;
     private aiModelsRaw;
+    private static readonly PREFS_KEY;
     ngAfterViewInit(): Promise<void>;
+    /**
+     * D9: Read incoming configuration from ResourceData (e.g. from Analytics tag navigation).
+     * Sets the initial tab and tag search query if provided.
+     */
+    private applyIncomingConfiguration;
+    /**
+     * D9: If a tagSearch parameter was provided via configuration, switch to the tags tab
+     * and apply the search filter after tag data loads.
+     */
+    private handleInitialTagSearch;
     ngOnDestroy(): void;
+    /** Report current classify dashboard state to the agent */
+    private emitAgentContext;
+    /** Register client tools the agent can invoke on the Classify dashboard */
+    private registerAgentTools;
     GetResourceDisplayName(_data: ResourceData): Promise<string>;
     GetResourceIconClass(_data: ResourceData): Promise<string>;
     SwitchTab(tab: TabName): Promise<void>;
@@ -234,9 +589,25 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     private buildPipelineStages;
     private buildFeedItems;
     private buildSourceMinis;
+    /**
+     * D6: Build trending tags weighted by recency (last 7 days).
+     * Counts tags from ContentItemTag records created in the last 7 days
+     * and weights by frequency. Falls back to all-time data if no recent tags.
+     */
     private buildTrendingTags;
+    /**
+     * Compute scored trending tags from a given set of tag records.
+     * Returns top 12 tags sorted by score (frequency x avg weight).
+     */
+    private computeTrendingFromTags;
     private loadSourcesData;
     private buildSourceCards;
+    /** Resolve the entity record ID from the EntityRecordDocument for entity-sourced content items */
+    private resolveEntityRecordID;
+    /** Resolve the entity name for an entity-sourced content source */
+    private resolveEntityName;
+    /** Check if a source type's Configuration says RequiresFileType !== false */
+    private sourceTypeRequiresFileType;
     private loadContentTypesData;
     private buildContentTypeCards;
     private loadTagLibraryData;
@@ -248,19 +619,104 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     /** Extract the ID string from a CompositeKey (from tree-dropdown ValueChange) */
     FromCompositeKey(key: CompositeKey | CompositeKey[] | null): string;
     FilterTags(): void;
+    /** Drill down into content items matching a specific tag */
+    DrillDownTag(tagName: string): void;
+    CloseDrillDownTag(): void;
     private loadRunHistoryData;
     private buildRunHistoryRows;
     private buildHistorySourceOptions;
     FilterRunHistory(): void;
+    /**
+     * D3/D8: Open the detail view for a specific run, loading ContentProcessRunDetail records.
+     */
+    OpenRunDetail(runID: string): Promise<void>;
+    /** D3/D8: Close the run detail slide-in */
+    CloseRunDetail(): void;
+    /**
+     * D2/D3/D8: Load ContentProcessRunDetail records for a given run and map to RunDetailRow[].
+     */
+    private loadRunDetailRows;
+    /**
+     * D2: Load live per-source progress for the currently running pipeline.
+     * Called when the pipeline is actively running.
+     */
+    LoadLiveRunDetails(): Promise<void>;
+    /** Map raw ContentProcessRunDetail records to RunDetailRow[] */
+    private mapRunDetailRecords;
     OpenAddSourceForm(): Promise<void>;
     OpenEditSourceForm(card: SourceCard): Promise<void>;
     SaveSource(): Promise<void>;
     DeleteSource(card: SourceCard): Promise<void>;
+    /**
+     * Opens the schedule dialog pre-filled for the given source card.
+     * Defaults to a daily 2 AM cron expression.
+     * @param card The source card to create a schedule for
+     */
+    OpenScheduleDialog(card: SourceCard): void;
+    /** Closes the schedule dialog without saving */
+    CloseScheduleDialog(): void;
+    /**
+     * Saves a new ScheduledAction for the current source, links it
+     * via ContentSource.ScheduledActionID, and creates the default
+     * action params for the Autotag and Vectorize action.
+     */
+    SaveSchedule(): Promise<void>;
+    /**
+     * Removes the schedule from a source card by unlinking the ScheduledActionID.
+     * @param card The source card to remove the schedule from
+     */
+    RemoveSchedule(card: SourceCard): Promise<void>;
+    /**
+     * Returns the human-readable schedule description for a source card.
+     * Used in the template to display schedule indicators.
+     */
+    GetScheduleLabel(card: SourceCard): string;
+    /**
+     * Returns a human-readable preview of a cron expression for the schedule dialog.
+     * @param cron The cron expression to preview
+     */
+    GetCronPreview(cron: string): string;
+    /** Looks up the cron expression for a cached ScheduledAction by ID */
+    private getScheduledActionCron;
+    /**
+     * Loads ScheduledAction entities referenced by content sources into the local cache.
+     * Called during initial data load so cron descriptions are available for card rendering.
+     */
+    private loadScheduledActionsForSources;
+    /** Finds the Action ID for "Autotag and Vectorize Content" by querying actions */
+    private findAutotagActionID;
+    /**
+     * Creates a ScheduledActionParam that passes the source ID to the action.
+     * Looks up the "EntityNames" action param and sets the source ID as its value.
+     */
+    private createSourceIDParam;
+    /**
+     * Links (or unlinks) a ScheduledAction to a ContentSource by updating
+     * the ContentSource.ScheduledActionID field.
+     */
+    private linkScheduleToSource;
     OpenAddTypeForm(): Promise<void>;
     OpenEditTypeForm(card: ContentTypeCard): Promise<void>;
     SaveContentType(): Promise<void>;
     CloseForm(): void;
-    RunPipeline(): Promise<void>;
+    /**
+     * Run the pipeline for a specific content source only.
+     */
+    RunPipelineForSource(contentSourceID: string): Promise<void>;
+    RunPipeline(contentSourceIDs?: string[]): Promise<void>;
+    /**
+     * Pause a running classification pipeline. The server sets CancellationRequested
+     * on the process run so the engine pauses gracefully after the current batch.
+     */
+    PausePipeline(): Promise<void>;
+    /**
+     * Resume a paused classification pipeline from its last completed offset.
+     */
+    ResumePipeline(): Promise<void>;
+    /**
+     * Cancel a running or paused pipeline. Uses pause mechanism and resets UI state.
+     */
+    CancelPipeline(): Promise<void>;
     private subscribeToPipelineProgress;
     private updateStagesForActiveRun;
     private formatStageName;
@@ -279,6 +735,10 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     private inferItemStatus;
     formatRelativeTime(dateStr: string | null | undefined): string;
     formatNumber(n: number): string;
+    /** Returns font size in rem for a tag based on its weight (0.0-1.0). Range: 0.7rem to 1.0rem */
+    TagFontSize(weight: number): string;
+    /** Format weight as percentage for display in tag chip */
+    FormatWeight(weight: number): string;
     private formatShortDate;
     private formatDate;
     private computeDuration;
@@ -292,9 +752,23 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     private refreshContentTypesTab;
     OpenFeedItemDetail(index: number): void;
     OpenContentItemDetail(item: ContentItemDetail): void;
+    /** Open content item detail slide-in by content item ID (used from tag drill-down) */
+    OpenItemDetailByID(contentItemID: string): void;
     CloseItemDetail(): void;
     OpenRecordFromItem(item: ContentItemDetail): void;
-    private getAllTagsForItem;
+    /** Cache: EntityRecordDocument ID → RecordID */
+    private entityRecordDocCache;
+    /** Load ERD RecordIDs for entity-sourced content items */
+    private loadEntityRecordDocCache;
+    private getAllWeightedTagsForItem;
+    /**
+     * D4: Infer embedding and tagging pipeline statuses for a content item.
+     * Uses tag count and run history heuristics since dedicated status columns
+     * are not yet available on the ContentItem entity.
+     */
+    private inferPipelineStatuses;
+    /** Map a raw status string to the ItemPipelineStatus union */
+    private mapStatusString;
     OpenSourceDetail(card: SourceCard): Promise<void>;
     CloseSourceDetail(): void;
     OpenRecordFromSource(source: SourceDetailInfo): void;
@@ -305,9 +779,207 @@ export declare class AutotaggingPipelineResourceComponent extends BaseResourceCo
     private loadRunHistoryForSource;
     private resolveEmbeddingModelName;
     private resolveVectorIndexName;
+    SwitchTaxSubTab(sub: TaxonomySubTab): void;
+    /**
+     * Loads all data needed by the Taxonomy Governance sub-tabs:
+     * Tags, Tagged Items, Tag Audit Logs, and cross-references content item tags.
+     */
+    private loadTaxonomyData;
+    /**
+     * Builds the taxonomy tree from raw tag data, wiring up parent-child
+     * relationships and attaching item counts and average weights.
+     */
+    private buildTaxTree;
+    private computeTreeDepths;
+    private propagateItemCounts;
+    private sortTreeNodes;
+    private flattenTree;
+    private computeTagHealth;
+    /**
+     * Counts the number of items referencing each tag, combining both
+     * Tagged Items and Content Item Tags. Uses NormalizeUUID for
+     * cross-platform UUID case consistency.
+     */
+    private countItemsByTag;
+    /**
+     * Computes the average weight per tag from Content Item Tags.
+     * Uses NormalizeUUID for cross-platform UUID case consistency.
+     */
+    private computeTagAvgWeights;
+    ToggleTaxNode(node: TaxTreeNode): void;
+    SelectTaxNode(node: TaxTreeNode): void;
+    FilterTaxTree(): void;
+    private applyTaxTreeFilter;
+    GetTaxBreadcrumb(node: TaxTreeNode): {
+        ID: string;
+        Name: string;
+    }[];
+    NavigateToBreadcrumb(tagId: string): void;
+    private loadRecentItemsForTag;
+    StartEditTag(): void;
+    CancelEditTag(): void;
+    SaveEditTag(): Promise<void>;
+    MoveTag(node: TaxTreeNode, newParentId: string | null): Promise<void>;
+    DeleteTag(node: TaxTreeNode): void;
+    /** Open create tag dialog for a root-level tag */
+    OpenCreateRootTag(): void;
+    /** Open create tag dialog as child of the selected node */
+    OpenCreateChildTag(): void;
+    /** Open create tag dialog as child of a specific node */
+    OpenCreateChildTagFor(node: TaxTreeNode): void;
+    /** Close create tag dialog */
+    CloseCreateTagDialog(): void;
+    /** Save the new tag */
+    SaveNewTag(): Promise<void>;
+    /** Toggle multi-select mode on/off */
+    ToggleMultiSelectMode(): void;
+    /** Toggle a node's selection in multi-select mode */
+    ToggleNodeSelection(node: TaxTreeNode, event: Event): void;
+    /** Check if a node is selected in multi-select mode */
+    IsNodeMultiSelected(nodeID: string): boolean;
+    /** Handle drag start on a tree node */
+    OnTreeNodeDragStart(event: DragEvent, node: TaxTreeNode): void;
+    /** Handle drag over a tree node (drop target) */
+    OnTreeNodeDragOver(event: DragEvent, node: TaxTreeNode): void;
+    /** Handle drag leave */
+    OnTreeNodeDragLeave(): void;
+    /** Handle drop — reparent dragged node(s) under the drop target */
+    OnTreeNodeDrop(event: DragEvent, targetNode: TaxTreeNode): Promise<void>;
+    /** Handle drop on the "Root" drop zone (make root-level) */
+    OnDropToRoot(event: DragEvent): Promise<void>;
+    MergeTags(sourceTagId: string, targetTagId: string, sourceName: string, targetName: string): Promise<void>;
+    MakeChildTag(childTagId: string, parentTagId: string): Promise<void>;
+    DismissDuplicate(pair: TaxDuplicatePair): void;
+    private buildTaxDuplicates;
+    /** Group tags by case-insensitive name, returning only groups with 2+ members */
+    private groupExactNameDuplicates;
+    /**
+     * Enhanced string similarity: separator normalization, abbreviation,
+     * pluralization, token-overlap Jaccard, containment, and Levenshtein.
+     * Returns the highest score among all heuristics.
+     */
+    private computeStringSimilarity;
+    /** Scores simple English pluralization differences */
+    private computePluralizationScore;
+    /** Jaccard similarity on word tokens */
+    private computeTokenJaccardSimilarity;
+    private isAbbreviationOf;
+    private levenshteinDistance;
+    /**
+     * Finds orphan tags: no parent, no children, and zero usage.
+     * A tag with even 1 connection is not orphaned — it's just a leaf.
+     * Uses NormalizeUUID for consistent cross-platform UUID comparisons.
+     */
+    private buildTaxOrphans;
+    ToggleOrphanSelection(orphan: TaxOrphanCard): void;
+    ToggleAllOrphans(): void;
+    DeleteOrphan(orphan: TaxOrphanCard): void;
+    BulkDeleteOrphans(): void;
+    /** Delete all orphan tags at once with a styled confirmation dialog */
+    DeleteAllOrphans(): void;
+    private buildTaxTreemap;
+    /**
+     * Builds the audit timeline from the MJ: Tag Audit Logs entity.
+     * Falls back to synthesizing "created" events from tag creation dates
+     * if no real audit log records exist yet.
+     */
+    private buildTaxAuditLog;
+    /**
+     * Maps real Tag Audit Log records into TaxAuditEvent objects.
+     * Uses the view's denormalized Tag, PerformedByUser, and RelatedTag fields.
+     */
+    private buildAuditEventsFromLogs;
+    /**
+     * Synthesizes audit events from tag __mj_CreatedAt dates when no
+     * real audit log records exist. Used as a fallback only.
+     */
+    private synthesizeAuditEventsFromTags;
+    /**
+     * Maps a PascalCase DB Action value (e.g. "Renamed") to the lowercase
+     * TaxAuditAction type used in the UI. Returns null for unrecognized values.
+     */
+    private mapAuditActionToType;
+    /**
+     * Safely parses the JSON Details column from a Tag Audit Log record.
+     * Returns an empty object on parse failure.
+     */
+    private parseAuditDetails;
+    /**
+     * Builds a human-readable description for an audit event based on the
+     * action type and any additional context from the related tag or details JSON.
+     */
+    private buildAuditDescription;
+    /**
+     * Adds a local-only audit entry to the top of the timeline for
+     * immediate UI feedback after a user action (merge, delete, etc.).
+     */
+    private addTaxAuditEntry;
+    ToggleTaxAuditFilter(type: string): void;
+    GetFilteredAuditEvents(): TaxAuditEvent[];
+    private formatDayHeader;
+    private buildTaxHealth;
+    /** Returns the Font Awesome icon class for an audit event action type. */
+    GetTaxAuditIcon(type: string): string;
+    /** Opens a styled confirmation dialog, replacing browser `confirm()`. */
+    OpenConfirmDialog(title: string, message: string, action: () => Promise<void>): void;
+    /** User confirmed the dialog action */
+    ConfirmDialogAccept(): Promise<void>;
+    /** User cancelled the confirmation dialog */
+    ConfirmDialogCancel(): void;
+    /** Opens the split-tag dialog for a given tree node */
+    OpenSplitDialog(node: TaxTreeNode): void;
+    /** Closes the split-tag dialog without action */
+    CloseSplitDialog(): void;
+    /** Executes the split operation, creating child tags from comma-separated names */
+    ExecuteSplit(): Promise<void>;
+    /** Opens the move-tag dialog for a given tree node */
+    OpenMoveDialog(node: TaxTreeNode): void;
+    /** Closes the move-tag dialog without action */
+    CloseMoveDialog(): void;
+    /** Returns flat list of tags eligible as move targets (excludes the node being moved and its descendants) */
+    GetMoveTargetOptions(): {
+        ID: string;
+        Name: string;
+        Depth: number;
+    }[];
+    /** Collects IDs of all descendants of a node */
+    private collectDescendantIds;
+    /** Executes the move operation */
+    ExecuteMove(): Promise<void>;
+    /** Opens treemap drill-in panel for the given cell */
+    OpenTreemapDrillIn(cell: TaxTreemapCell): void;
+    /** Closes treemap drill-in panel */
+    CloseTreemapDrillIn(): void;
+    /** Navigate from treemap drill-in to the tag in the tree view */
+    DrillInToTreeView(node: TaxTreeNode): void;
+    RefreshTaxonomyData(): Promise<void>;
+    /** Load pending content item duplicates for review */
+    LoadContentDuplicates(): Promise<void>;
+    /** Resolve content source names for a list of content item IDs */
+    private resolveItemSourceNames;
+    /** Confirm a content duplicate pair */
+    ConfirmContentDuplicate(dupRow: ContentDuplicateRow): Promise<void>;
+    /** Dismiss a content duplicate pair */
+    DismissContentDuplicate(dupRow: ContentDuplicateRow): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AutotaggingPipelineResourceComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AutotaggingPipelineResourceComponent, "app-autotagging-pipeline-resource", never, {}, {}, never, never, false, never>;
 }
 export declare function LoadAutotaggingPipelineResource(): void;
+/**
+ * Converts a 5-part or 6-part cron expression to a human-readable English string.
+ *
+ * Handles common patterns:
+ *   `0 * * * *`      -> "Every hour"
+ *   `0 2 * * *`      -> "Daily at 2:00 AM"
+ *   `0 2 * * 1`      -> "Weekly on Monday at 2:00 AM"
+ *   `star/15 * * * *` -> "Every 15 minutes"  (where star = asterisk)
+ *   `0 0 1 * *`      -> "Monthly on day 1 at 12:00 AM"
+ *
+ * Falls back to returning the raw cron string for unrecognized patterns.
+ *
+ * @param cron A cron expression string (5 or 6 parts)
+ * @returns A human-readable description or the raw cron if unrecognized
+ */
+export declare function CronToHumanReadable(cron: string): string;
 export {};
 //# sourceMappingURL=autotagging-pipeline-resource.component.d.ts.map