@memberjunction/ng-dashboards 5.22.0 → 5.24.0

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

@@ -1,102 +1,985 @@
 /**
- * @fileoverview Content Autotagging Pipeline Monitor
+ * @fileoverview Content Autotagging Dashboard
  *
- * Operations dashboard for monitoring the content autotagging pipeline.
- * Displays KPI metrics, pipeline stage visualization, recent processing feed,
- * and source configuration status.
+ * Full dashboard for the content autotagging pipeline with left-nav and 5 tabs:
+ * Pipeline Monitor, Sources Management, Content Types, Tag Library, Run History.
+ * Supports CRUD on sources and content types via slide-in forms,
+ * pipeline triggering with real-time GraphQL subscription progress.
  */
 import { OnDestroy, AfterViewInit } from '@angular/core';
-import { ResourceData } from '@memberjunction/core-entities';
+import { CompositeKey } from '@memberjunction/core';
+import { TreeBranchConfig, TreeLeafConfig } from '@memberjunction/ng-trees';
+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";
-/** Represents a single pipeline stage with its current status */
-interface PipelineStage {
+type TabName = 'pipeline' | 'sources' | 'types' | 'tags' | 'taxonomy' | 'history';
+interface NavItem {
+    Tab: TabName;
+    Icon: string;
+    Label: string;
+    BadgeText: string;
+    BadgeClass: string;
+}
+interface KPIMetric {
+    Label: string;
+    Value: number;
+    Icon: string;
+    Trend: string;
+    TrendUp: boolean;
+}
+interface PipelineStageInfo {
     Name: string;
     Icon: string;
-    ActiveCount: number;
-    Status: 'idle' | 'active' | 'error';
+    Status: 'idle' | 'active' | 'complete';
+    Count: string;
 }
-/** Summary of a recently processed content item */
-interface ProcessedItem {
+interface FeedItem {
     Name: string;
     SourceName: string;
-    ProcessingTimeMs: number;
-    Status: 'Complete' | 'Error' | 'Processing';
+    Tags: string[];
+    TimeAgo: string;
+    Status: 'complete' | 'processing' | 'error';
+}
+interface SourceMini {
+    ID: string;
+    Name: string;
+    Icon: string;
+    Meta: string;
+    StatusClass: 'active' | 'error' | 'inactive';
+}
+interface SourceCard {
+    ID: string;
+    Name: string;
+    SourceTypeName: string;
+    ContentTypeName: string;
+    FileTypeName: string;
+    Icon: string;
+    StatusClass: 'active' | 'error' | 'inactive';
+    StatusLabel: string;
+    URL: string;
+    ItemCount: number;
     TagCount: number;
-    ProcessedAt: Date;
+    AvgTags: string;
+    LastRunAgo: string;
+    ContentSourceTypeID: string;
+    ContentTypeID: string;
+    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;
+    Name: string;
+    Description: string;
+    AIModelName: string;
+    AIModelID: string;
+    MinTags: number;
+    MaxTags: number;
+    SourcesUsing: number;
+    ItemsTagged: number;
+    RangeLeftPct: number;
+    RangeRightPct: number;
+    EmbeddingModelID: string;
+    VectorIndexID: string;
+}
+interface TagRow {
+    Tag: string;
+    UsageCount: number;
+    AvgWeight: number;
+    BarWidthPct: number;
+    TopSource: string;
+    FirstSeen: string;
+}
+interface TagCloudItem {
+    Tag: string;
+    AvgWeight: number;
+    SizeClass: 'large' | '' | 'small';
+}
+interface TagBySource {
+    SourceName: string;
+    Count: number;
+}
+interface RunHistoryRow {
+    ID: string;
+    Status: string;
+    StatusClass: string;
+    SourceName: string;
+    StartedDisplay: string;
+    Duration: string;
+    Items: string;
+    Tags: string;
+    Errors: string;
+    ErrorClass: string;
+}
+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;
 }
-/** Summary of a configured content source */
-interface ContentSource {
+type TaxonomySubTab = 'tree' | 'duplicates' | 'orphans' | 'treemap' | 'audit';
+interface TaxTreeNode {
     ID: string;
     Name: string;
-    TypeName: string;
-    TypeIcon: string;
-    Status: 'Active' | 'Paused' | 'Error';
-    LastRunAt: Date | null;
+    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;
 }
-/** KPI metric card data */
-interface KPIMetric {
-    Label: string;
-    Value: number;
-    Icon: 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;
+    SourceName: string;
+    SourceTypeName: string;
+    ContentTypeName: string;
+    FileTypeName: string;
+    URL: string;
+    TextContent: string;
+    Checksum: 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;
+    Name: string;
+    SourceTypeName: string;
+    FileTypeName: string;
+    ContentTypeName: string;
+    RequiresFileType: boolean;
+    StatusClass: 'active' | 'error' | 'inactive';
+    StatusLabel: string;
+    Icon: string;
+    URL: string;
+    EmbeddingModelName: string;
+    VectorIndexName: string;
+    ItemCount: number;
+    TagCount: number;
+    AvgTags: string;
+    LastRunAgo: string;
+    ErrorCount: number;
+    ContentItems: ContentItemDetail[];
+    RunHistory: RunHistoryRow[];
+}
+type FormMode = 'none' | 'add-source' | 'edit-source' | 'add-type' | 'edit-type';
 export declare class AutotaggingPipelineResourceComponent extends BaseResourceComponent implements AfterViewInit, OnDestroy {
     private destroy$;
+    private cdr;
+    private navigationService;
     IsLoading: boolean;
-    ErrorMessage: string;
+    ActiveTab: TabName;
+    private tabDataLoaded;
+    NavItems: NavItem[];
     KPIMetrics: KPIMetric[];
-    PipelineStages: PipelineStage[];
-    ProcessedItems: ProcessedItem[];
-    ContentSources: ContentSource[];
-    private contentItems;
-    private contentRuns;
-    private contentTags;
-    private contentSourceTypes;
+    PipelineStages: PipelineStageInfo[];
+    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;
+    FormSourceTypeID: string;
+    FormContentTypeID: string;
+    FormFileTypeID: string;
+    FormSourceURL: string;
+    EditingSourceID: string;
+    FormTypeName: string;
+    FormTypeDescription: string;
+    FormTypeAIModelID: string;
+    FormTypeMinTags: number;
+    FormTypeMaxTags: number;
+    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[];
+    AIModelOptions: DropdownOption[];
+    EmbeddingModelOptions: DropdownOption[];
+    VectorIndexOptions: DropdownOption[];
+    AIModelVendorBranch: TreeBranchConfig;
+    AllModelsLeaf: TreeLeafConfig;
+    EmbeddingModelsLeaf: TreeLeafConfig;
     private contentSourcesRaw;
-    private cdr;
+    private contentItemsRaw;
+    private contentTagsRaw;
+    private contentRunsRaw;
+    private contentSourceTypesRaw;
+    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>;
-    /** Load all pipeline data from MJ entities */
-    LoadData(): Promise<void>;
-    /** Refresh pipeline status data */
-    RefreshData(): Promise<void>;
-    /** Format milliseconds into a human-readable duration */
-    FormatDuration(ms: number): string;
-    /** Format a date as a relative time string */
-    FormatRelativeTime(date: Date | null): string;
-    /** Get CSS class for a processing status */
-    GetStatusClass(status: string): string;
-    /** Get icon for a source type */
-    GetSourceTypeIcon(typeName: string): string;
-    /** Build KPI metrics from loaded data */
+    SwitchTab(tab: TabName): Promise<void>;
+    private loadTabData;
+    LoadPipelineData(): Promise<void>;
+    private buildNavItems;
     private buildKPIMetrics;
-    /** Build pipeline stage visualization data */
     private buildPipelineStages;
-    /** Group content runs by their processing stage */
-    private groupRunsByStage;
-    /** Create a pipeline stage object from run data */
-    private createStage;
-    /** Build the recent processing feed from content items and tags */
-    private buildProcessedItems;
-    /** Count tags per content item */
+    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;
+    private buildTagRows;
+    private buildTagCloud;
+    private buildTagsBySource;
+    /** Convert a string ID to a CompositeKey for tree-dropdown binding */
+    ToCompositeKey(id: string | null | undefined): CompositeKey | null;
+    /** 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;
+    /**
+     * 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;
     private countTagsByItem;
-    /** Map raw status values to display status */
-    private mapItemStatus;
-    /** Build content source summaries from raw data */
-    private buildContentSources;
-    /** Build a map of source type IDs to names */
-    private buildTypeMap;
-    /** Count content items per source */
+    private getTopTagsForItem;
     private countItemsBySource;
-    /** Map raw source status to display status */
-    private mapSourceStatus;
+    private countTagsBySource;
+    private getLastRunBySource;
+    private countAllTags;
+    /** Compute average weight per tag across all occurrences */
+    private computeAvgWeights;
+    private getTopSourcePerTag;
+    private getFirstSeenPerTag;
+    private countSourcesByContentType;
+    private countItemsByContentType;
+    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;
+    private displayStatus;
+    GetSourceTypeIcon(typeName: string): string;
+    private ensureBaseDataLoaded;
+    private ensureFormDropdownsLoaded;
+    private resetSourceForm;
+    private resetTypeForm;
+    private refreshSourcesTab;
+    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;
+    /** 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;
+    OpenEditSourceFromDetail(): void;
+    RunSourceFromDetail(): Promise<void>;
+    DeleteSourceFromDetail(): Promise<void>;
+    private loadContentItemsForSource;
+    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