@nice2dev/ui-tools 1.0.10

package/dist/self-service-analytics.d.ts

@@ -0,0 +1,1208 @@
+/**
+ * @file self-service-analytics.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-15.5 — Self-Service Analytics
+ *
+ * Types for no-code analytics: natural language query, auto-visualization,
+ * data storytelling, explorations, metrics catalog, collaboration.
+ */
+/** Analytics capability */
+export type AnalyticsCapability = 'naturalLanguage' | 'autoVisualization' | 'dataStorytelling' | 'explorations' | 'metrics' | 'glossary' | 'collaboration' | 'certification';
+/** Visualization mode */
+export type VisualizationMode = 'auto' | 'manual' | 'guided' | 'assistant';
+/** Data granularity */
+export type DataGranularity = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year' | 'custom';
+/** Sharing level */
+export type SharingLevel = 'private' | 'team' | 'organization' | 'public';
+/** Self-service analytics configuration */
+export interface SelfServiceAnalyticsConfig {
+    /** Enabled capabilities */
+    capabilities?: AnalyticsCapability[];
+    /** Data sources */
+    dataSources?: AnalyticsDataSource[];
+    /** Theme */
+    theme?: AnalyticsTheme;
+    /** Locale */
+    locale?: string;
+    /** Natural language config */
+    nlQuery?: NaturalLanguageConfig;
+    /** Auto-visualization config */
+    autoViz?: AutoVisualizationConfig;
+    /** Storytelling config */
+    storytelling?: StorytellingConfig;
+    /** Glossary config */
+    glossary?: GlossaryConfig;
+    /** Metrics config */
+    metricsConfig?: MetricsConfig;
+    /** Collaboration config */
+    collaboration?: AnalyticsCollaborationConfig;
+}
+/** Analytics data source */
+export interface AnalyticsDataSource {
+    id: string;
+    name: string;
+    type: DataSourceType;
+    connection?: AnalyticsConnection;
+    schema?: DataSchema;
+    permissions?: DataSourcePermission[];
+    certified?: boolean;
+    owner?: string;
+    description?: string;
+    tags?: string[];
+}
+/** Data source type */
+export type DataSourceType = 'database' | 'warehouse' | 'spreadsheet' | 'api' | 'file' | 'stream' | 'semantic' | 'cube';
+/** Analytics connection */
+export interface AnalyticsConnection {
+    type: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    schema?: string;
+    username?: string;
+    credentials?: CredentialReference;
+    options?: Record<string, unknown>;
+}
+/** Credential reference */
+export interface CredentialReference {
+    type: 'stored' | 'oauth' | 'serviceAccount' | 'environment';
+    id?: string;
+    provider?: string;
+}
+/** Data schema */
+export interface DataSchema {
+    tables: AnalyticsTable[];
+    relationships?: TableRelationship[];
+    metrics?: MetricDefinition[];
+    dimensions?: DimensionDefinition[];
+}
+/** Analytics table */
+export interface AnalyticsTable {
+    id: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    columns: AnalyticsColumn[];
+    rowCount?: number;
+    certified?: boolean;
+    tags?: string[];
+}
+/** Analytics column */
+export interface AnalyticsColumn {
+    id: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    dataType: AnalyticsDataType;
+    semanticType?: SemanticType;
+    format?: ColumnFormat;
+    nullable?: boolean;
+    unique?: boolean;
+    primaryKey?: boolean;
+    foreignKey?: ForeignKeyReference;
+    aggregation?: AggregationType;
+    certified?: boolean;
+    hidden?: boolean;
+    synonyms?: string[];
+}
+/** Analytics data type */
+export type AnalyticsDataType = 'string' | 'number' | 'integer' | 'decimal' | 'boolean' | 'date' | 'datetime' | 'time' | 'timestamp' | 'json' | 'array' | 'geography' | 'binary';
+/** Semantic type */
+export type SemanticType = 'id' | 'name' | 'description' | 'email' | 'phone' | 'url' | 'address' | 'city' | 'state' | 'country' | 'postalCode' | 'latitude' | 'longitude' | 'currency' | 'percentage' | 'quantity' | 'price' | 'revenue' | 'cost' | 'date' | 'datetime' | 'duration' | 'status' | 'category' | 'tag' | 'image' | 'custom';
+/** Column format */
+export interface ColumnFormat {
+    type?: string;
+    pattern?: string;
+    locale?: string;
+    currency?: string;
+    decimals?: number;
+    prefix?: string;
+    suffix?: string;
+}
+/** Foreign key reference */
+export interface ForeignKeyReference {
+    table: string;
+    column: string;
+}
+/** Aggregation type */
+export type AggregationType = 'sum' | 'avg' | 'min' | 'max' | 'count' | 'countDistinct' | 'first' | 'last' | 'median' | 'mode' | 'stddev' | 'variance' | 'percentile' | 'custom';
+/** Table relationship */
+export interface TableRelationship {
+    id: string;
+    name?: string;
+    sourceTable: string;
+    sourceColumn: string;
+    targetTable: string;
+    targetColumn: string;
+    type: RelationshipType;
+    active?: boolean;
+}
+/** Relationship type */
+export type RelationshipType = 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany';
+/** Data source permission */
+export interface DataSourcePermission {
+    principal: string;
+    principalType: 'user' | 'group' | 'role';
+    level: 'read' | 'write' | 'admin';
+    columns?: string[];
+    rowFilter?: string;
+}
+/** Analytics theme */
+export interface AnalyticsTheme {
+    name?: string;
+    colors?: ThemeColors;
+    fonts?: ThemeFonts;
+    spacing?: ThemeSpacing;
+    charts?: ChartTheme;
+}
+/** Theme colors */
+export interface ThemeColors {
+    primary?: string;
+    secondary?: string;
+    background?: string;
+    surface?: string;
+    text?: string;
+    border?: string;
+    success?: string;
+    warning?: string;
+    error?: string;
+    info?: string;
+    palette?: string[];
+}
+/** Theme fonts */
+export interface ThemeFonts {
+    heading?: string;
+    body?: string;
+    mono?: string;
+    sizes?: Record<string, string>;
+}
+/** Theme spacing */
+export interface ThemeSpacing {
+    unit?: number;
+    scale?: number[];
+}
+/** Chart theme */
+export interface ChartTheme {
+    colorPalette?: string[];
+    backgroundColor?: string;
+    gridColor?: string;
+    axisColor?: string;
+    labelColor?: string;
+    fontFamily?: string;
+}
+/** Natural language configuration */
+export interface NaturalLanguageConfig {
+    enabled?: boolean;
+    model?: NLQModel;
+    training?: NLQTraining;
+    suggestions?: NLQSuggestions;
+    feedback?: NLQFeedback;
+    limits?: NLQLimits;
+}
+/** NLQ model */
+export interface NLQModel {
+    provider: 'openai' | 'anthropic' | 'azure' | 'vertexai' | 'local';
+    modelId?: string;
+    apiKey?: string;
+    endpoint?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+/** NLQ training */
+export interface NLQTraining {
+    examples?: NLQExample[];
+    synonyms?: SynonymMapping[];
+    customTerms?: CustomTerm[];
+    domainContext?: string;
+}
+/** NLQ example */
+export interface NLQExample {
+    question: string;
+    query: string;
+    tables?: string[];
+    metrics?: string[];
+}
+/** Synonym mapping */
+export interface SynonymMapping {
+    term: string;
+    synonyms: string[];
+    type: 'table' | 'column' | 'metric' | 'dimension' | 'value';
+    object?: string;
+}
+/** Custom term */
+export interface CustomTerm {
+    term: string;
+    definition: string;
+    expression?: string;
+    type: 'measure' | 'calculation' | 'filter' | 'concept';
+}
+/** NLQ suggestions */
+export interface NLQSuggestions {
+    enabled?: boolean;
+    maxSuggestions?: number;
+    includeExamples?: boolean;
+    includePopular?: boolean;
+}
+/** NLQ feedback */
+export interface NLQFeedback {
+    enabled?: boolean;
+    collectExamples?: boolean;
+    improvementLoop?: boolean;
+}
+/** NLQ limits */
+export interface NLQLimits {
+    maxQuestionLength?: number;
+    maxResultRows?: number;
+    timeout?: number;
+    dailyQueries?: number;
+}
+/** Natural language query request */
+export interface NLQueryRequest {
+    question: string;
+    context?: NLQueryContext;
+    options?: NLQueryOptions;
+}
+/** NL query context */
+export interface NLQueryContext {
+    dataSource?: string;
+    tables?: string[];
+    previousQueries?: string[];
+    filters?: Record<string, unknown>;
+    timeRange?: TimeRange;
+}
+/** Time range */
+export interface TimeRange {
+    start?: Date;
+    end?: Date;
+    period?: string;
+    granularity?: DataGranularity;
+}
+/** NL query options */
+export interface NLQueryOptions {
+    explain?: boolean;
+    suggestAlternatives?: boolean;
+    autoCorrect?: boolean;
+    limit?: number;
+}
+/** Natural language query response */
+export interface NLQueryResponse {
+    success: boolean;
+    question: string;
+    interpretation?: QueryInterpretation;
+    query?: GeneratedQuery;
+    results?: QueryResults;
+    visualization?: SuggestedVisualization;
+    alternatives?: AlternativeQuery[];
+    clarifications?: Clarification[];
+    error?: NLQueryError;
+}
+/** Query interpretation */
+export interface QueryInterpretation {
+    intent: QueryIntent;
+    entities: ExtractedEntity[];
+    confidence: number;
+    explanation?: string;
+}
+/** Query intent */
+export interface QueryIntent {
+    type: 'aggregate' | 'filter' | 'compare' | 'trend' | 'breakdown' | 'list' | 'lookup';
+    metrics?: string[];
+    dimensions?: string[];
+    filters?: string[];
+    timeRange?: boolean;
+    groupBy?: boolean;
+    orderBy?: boolean;
+}
+/** Extracted entity */
+export interface ExtractedEntity {
+    text: string;
+    type: EntityType;
+    value?: unknown;
+    table?: string;
+    column?: string;
+    confidence: number;
+}
+/** Entity type */
+export type EntityType = 'metric' | 'dimension' | 'filter' | 'timeExpression' | 'aggregation' | 'comparison' | 'limit' | 'sort' | 'value' | 'operator';
+/** Generated query */
+export interface GeneratedQuery {
+    sql: string;
+    dataSource: string;
+    tables: string[];
+    columns: string[];
+    confidence: number;
+}
+/** Query results */
+export interface QueryResults {
+    columns: ResultColumnInfo[];
+    rows: unknown[][];
+    rowCount: number;
+    truncated?: boolean;
+    executionTime?: number;
+}
+/** Result column info */
+export interface ResultColumnInfo {
+    name: string;
+    displayName?: string;
+    dataType: AnalyticsDataType;
+    semanticType?: SemanticType;
+    format?: ColumnFormat;
+    aggregation?: AggregationType;
+}
+/** Suggested visualization */
+export interface SuggestedVisualization {
+    type: VisualizationType;
+    config: VisualizationConfig;
+    alternatives?: VisualizationType[];
+    reasoning?: string;
+}
+/** Visualization type */
+export type VisualizationType = 'table' | 'bar' | 'line' | 'area' | 'pie' | 'donut' | 'scatter' | 'bubble' | 'heatmap' | 'treemap' | 'funnel' | 'gauge' | 'kpi' | 'map' | 'sankey' | 'waterfall' | 'boxplot' | 'histogram' | 'radar' | 'combo';
+/** Visualization config */
+export interface VisualizationConfig {
+    type: VisualizationType;
+    title?: string;
+    xAxis?: AxisConfig;
+    yAxis?: AxisConfig;
+    series?: SeriesConfig[];
+    legend?: LegendConfig;
+    colors?: string[];
+    options?: Record<string, unknown>;
+}
+/** Axis config */
+export interface AxisConfig {
+    field?: string;
+    label?: string;
+    type?: 'category' | 'value' | 'time' | 'log';
+    format?: string;
+    min?: number;
+    max?: number;
+}
+/** Series config */
+export interface SeriesConfig {
+    field: string;
+    name?: string;
+    type?: string;
+    color?: string;
+    aggregation?: AggregationType;
+}
+/** Legend config */
+export interface LegendConfig {
+    show?: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    orientation?: 'horizontal' | 'vertical';
+}
+/** Alternative query */
+export interface AlternativeQuery {
+    question: string;
+    query: string;
+    explanation?: string;
+}
+/** Clarification */
+export interface Clarification {
+    type: 'ambiguous' | 'missing' | 'suggestion';
+    message: string;
+    options?: ClarificationOption[];
+}
+/** Clarification option */
+export interface ClarificationOption {
+    label: string;
+    value: string;
+    description?: string;
+}
+/** NL query error */
+export interface NLQueryError {
+    code: string;
+    message: string;
+    suggestion?: string;
+    details?: Record<string, unknown>;
+}
+/** Auto-visualization configuration */
+export interface AutoVisualizationConfig {
+    enabled?: boolean;
+    rules?: VisualizationRule[];
+    preferences?: VisualizationPreferences;
+    recommendations?: RecommendationConfig;
+}
+/** Visualization rule */
+export interface VisualizationRule {
+    id: string;
+    name: string;
+    priority: number;
+    conditions: RuleCondition[];
+    visualization: VisualizationType;
+    config?: Partial<VisualizationConfig>;
+}
+/** Rule condition */
+export interface RuleCondition {
+    type: ConditionType;
+    field?: string;
+    operator: ConditionOperator;
+    value?: unknown;
+}
+/** Condition type */
+export type ConditionType = 'columnCount' | 'rowCount' | 'dataType' | 'cardinality' | 'semanticType' | 'aggregation' | 'hasTime' | 'hasGeo';
+/** Condition operator */
+export type ConditionOperator = 'equals' | 'notEquals' | 'greaterThan' | 'lessThan' | 'between' | 'contains' | 'startsWith' | 'in';
+/** Visualization preferences */
+export interface VisualizationPreferences {
+    defaultChartType?: VisualizationType;
+    colorPalette?: string[];
+    showDataLabels?: boolean;
+    showLegend?: boolean;
+    showTooltips?: boolean;
+    animations?: boolean;
+    responsive?: boolean;
+}
+/** Recommendation config */
+export interface RecommendationConfig {
+    maxRecommendations?: number;
+    includeExplanations?: boolean;
+    learnFromUsage?: boolean;
+}
+/** Visualization recommendation */
+export interface VisualizationRecommendation {
+    type: VisualizationType;
+    score: number;
+    reasoning: string;
+    config: VisualizationConfig;
+    insights?: DataInsight[];
+}
+/** Data insight */
+export interface DataInsight {
+    type: InsightType;
+    message: string;
+    importance: 'low' | 'medium' | 'high';
+    data?: Record<string, unknown>;
+}
+/** Insight type */
+export type InsightType = 'trend' | 'anomaly' | 'correlation' | 'outlier' | 'distribution' | 'seasonality' | 'comparison' | 'summary';
+/** Storytelling configuration */
+export interface StorytellingConfig {
+    enabled?: boolean;
+    templates?: StoryTemplate[];
+    narration?: NarrationConfig;
+    animations?: AnimationConfig;
+    export?: StoryExportConfig;
+}
+/** Story template */
+export interface StoryTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    thumbnail?: string;
+    layout: StoryLayout;
+    placeholders: TemplatePlaceholder[];
+    theme?: StoryTheme;
+}
+/** Story layout */
+export interface StoryLayout {
+    type: 'scroll' | 'slideshow' | 'dashboard' | 'infographic';
+    sections: LayoutSection[];
+}
+/** Layout section */
+export interface LayoutSection {
+    id: string;
+    type: SectionType;
+    position?: Position;
+    size?: Size;
+    children?: string[];
+}
+/** Section type */
+export type SectionType = 'hero' | 'text' | 'chart' | 'kpi' | 'table' | 'image' | 'video' | 'comparison' | 'timeline' | 'callout';
+/** Position */
+export interface Position {
+    x: number;
+    y: number;
+}
+/** Size */
+export interface Size {
+    width: number;
+    height: number;
+}
+/** Template placeholder */
+export interface TemplatePlaceholder {
+    id: string;
+    type: 'data' | 'text' | 'visualization' | 'media';
+    label: string;
+    required?: boolean;
+    defaultValue?: unknown;
+    constraints?: PlaceholderConstraint;
+}
+/** Placeholder constraint */
+export interface PlaceholderConstraint {
+    dataTypes?: AnalyticsDataType[];
+    visualizationTypes?: VisualizationType[];
+    minRows?: number;
+    maxRows?: number;
+    minColumns?: number;
+    maxColumns?: number;
+}
+/** Story theme */
+export interface StoryTheme {
+    name?: string;
+    fonts?: ThemeFonts;
+    colors?: ThemeColors;
+    backgrounds?: BackgroundStyle[];
+    transitions?: TransitionStyle[];
+}
+/** Background style */
+export interface BackgroundStyle {
+    type: 'solid' | 'gradient' | 'image' | 'pattern';
+    value: string;
+    opacity?: number;
+}
+/** Transition style */
+export interface TransitionStyle {
+    type: 'fade' | 'slide' | 'zoom' | 'flip' | 'none';
+    duration?: number;
+    easing?: string;
+}
+/** Narration configuration */
+export interface NarrationConfig {
+    enabled?: boolean;
+    autoGenerate?: boolean;
+    voice?: VoiceConfig;
+    style?: NarrationStyle;
+}
+/** Voice config */
+export interface VoiceConfig {
+    provider?: 'browser' | 'azure' | 'aws' | 'google';
+    language?: string;
+    voice?: string;
+    rate?: number;
+    pitch?: number;
+}
+/** Narration style */
+export type NarrationStyle = 'formal' | 'conversational' | 'technical' | 'executive';
+/** Animation configuration */
+export interface AnimationConfig {
+    enabled?: boolean;
+    chartAnimations?: boolean;
+    transitionAnimations?: boolean;
+    scrollAnimations?: boolean;
+    speed?: 'slow' | 'normal' | 'fast';
+}
+/** Story export configuration */
+export interface StoryExportConfig {
+    formats?: ('pdf' | 'pptx' | 'png' | 'gif' | 'video' | 'html')[];
+    quality?: 'low' | 'medium' | 'high';
+    includeInteractive?: boolean;
+}
+/** Data story */
+export interface DataStory {
+    id: string;
+    title: string;
+    description?: string;
+    thumbnail?: string;
+    template?: string;
+    sections: StorySection[];
+    theme?: StoryTheme;
+    narration?: StoryNarration;
+    metadata?: StoryMetadata;
+}
+/** Story section */
+export interface StorySection {
+    id: string;
+    type: SectionType;
+    title?: string;
+    content?: SectionContent;
+    data?: SectionData;
+    visualization?: SectionVisualization;
+    narration?: string;
+    animation?: SectionAnimation;
+    duration?: number;
+}
+/** Section content */
+export interface SectionContent {
+    text?: string;
+    markdown?: string;
+    html?: string;
+    image?: MediaReference;
+    video?: MediaReference;
+}
+/** Media reference */
+export interface MediaReference {
+    url: string;
+    alt?: string;
+    caption?: string;
+}
+/** Section data */
+export interface SectionData {
+    query?: string;
+    dataSource?: string;
+    filters?: Record<string, unknown>;
+    results?: QueryResults;
+}
+/** Section visualization */
+export interface SectionVisualization {
+    type: VisualizationType;
+    config: VisualizationConfig;
+    highlights?: VisualizationHighlight[];
+    annotations?: VisualizationAnnotation[];
+}
+/** Visualization highlight */
+export interface VisualizationHighlight {
+    type: 'point' | 'range' | 'series';
+    target: unknown;
+    style?: HighlightStyle;
+    annotation?: string;
+}
+/** Highlight style */
+export interface HighlightStyle {
+    color?: string;
+    opacity?: number;
+    strokeWidth?: number;
+    pulse?: boolean;
+}
+/** Visualization annotation */
+export interface VisualizationAnnotation {
+    type: 'text' | 'arrow' | 'line' | 'area';
+    position: Position;
+    content?: string;
+    style?: AnnotationStyle;
+}
+/** Annotation style */
+export interface AnnotationStyle {
+    color?: string;
+    fontSize?: number;
+    fontWeight?: string;
+    background?: string;
+}
+/** Section animation */
+export interface SectionAnimation {
+    enter?: TransitionStyle;
+    exit?: TransitionStyle;
+    dataAnimation?: DataAnimation;
+}
+/** Data animation */
+export interface DataAnimation {
+    type: 'reveal' | 'grow' | 'morph' | 'highlight';
+    sequence?: 'all' | 'series' | 'point';
+    duration?: number;
+    delay?: number;
+}
+/** Story narration */
+export interface StoryNarration {
+    generated?: boolean;
+    voice?: VoiceConfig;
+    sections: NarrationSection[];
+}
+/** Narration section */
+export interface NarrationSection {
+    sectionId: string;
+    text: string;
+    timing?: NarrationTiming;
+    audio?: AudioReference;
+}
+/** Narration timing */
+export interface NarrationTiming {
+    start: number;
+    duration: number;
+}
+/** Audio reference */
+export interface AudioReference {
+    url: string;
+    duration: number;
+    format: string;
+}
+/** Story metadata */
+export interface StoryMetadata {
+    created?: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    version?: number;
+    tags?: string[];
+    sharing?: SharingLevel;
+    views?: number;
+    likes?: number;
+    comments?: number;
+}
+/** Exploration */
+export interface Exploration {
+    id: string;
+    name: string;
+    description?: string;
+    dataSource: string;
+    query: ExplorationQuery;
+    visualization?: VisualizationConfig;
+    filters?: ExplorationFilter[];
+    calculations?: Calculation[];
+    insights?: DataInsight[];
+    metadata?: ExplorationMetadata;
+}
+/** Exploration query */
+export interface ExplorationQuery {
+    table?: string;
+    tables?: string[];
+    columns?: ExplorationColumn[];
+    metrics?: string[];
+    dimensions?: string[];
+    filters?: FilterExpression[];
+    groupBy?: string[];
+    orderBy?: OrderByExpression[];
+    limit?: number;
+    sql?: string;
+}
+/** Exploration column */
+export interface ExplorationColumn {
+    field: string;
+    alias?: string;
+    aggregation?: AggregationType;
+    format?: ColumnFormat;
+    hidden?: boolean;
+}
+/** Filter expression */
+export interface FilterExpression {
+    field: string;
+    operator: FilterOperator;
+    value?: unknown;
+    values?: unknown[];
+}
+/** Filter operator */
+export type FilterOperator = 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEquals' | 'lessThan' | 'lessThanOrEquals' | 'between' | 'notBetween' | 'in' | 'notIn' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'isNull' | 'isNotNull' | 'isEmpty' | 'isNotEmpty' | 'regex';
+/** Order by expression */
+export interface OrderByExpression {
+    field: string;
+    direction: 'asc' | 'desc';
+    nulls?: 'first' | 'last';
+}
+/** Exploration filter */
+export interface ExplorationFilter {
+    id: string;
+    name: string;
+    field: string;
+    type: FilterType;
+    operator?: FilterOperator;
+    value?: unknown;
+    values?: unknown[];
+    options?: FilterOption[];
+    multiple?: boolean;
+    required?: boolean;
+}
+/** Filter type */
+export type FilterType = 'text' | 'number' | 'date' | 'dateRange' | 'select' | 'multiSelect' | 'slider' | 'checkbox' | 'radio' | 'search';
+/** Filter option */
+export interface FilterOption {
+    label: string;
+    value: unknown;
+    count?: number;
+}
+/** Calculation */
+export interface Calculation {
+    id: string;
+    name: string;
+    expression: string;
+    dataType?: AnalyticsDataType;
+    format?: ColumnFormat;
+    description?: string;
+}
+/** Exploration metadata */
+export interface ExplorationMetadata {
+    created?: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    version?: number;
+    folder?: string;
+    tags?: string[];
+    sharing?: SharingLevel;
+    starred?: boolean;
+    runCount?: number;
+    lastRun?: Date;
+}
+/** Metrics configuration */
+export interface MetricsConfig {
+    enabled?: boolean;
+    catalog?: MetricsCatalog;
+    governance?: MetricsGovernance;
+    lineage?: boolean;
+}
+/** Metrics catalog */
+export interface MetricsCatalog {
+    id: string;
+    name: string;
+    description?: string;
+    metrics: MetricDefinition[];
+    dimensions: DimensionDefinition[];
+    categories: MetricCategory[];
+}
+/** Metric definition */
+export interface MetricDefinition {
+    id: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    expression: string;
+    dataType: 'number' | 'integer' | 'decimal' | 'currency' | 'percentage';
+    format?: ColumnFormat;
+    aggregation: AggregationType;
+    table?: string;
+    column?: string;
+    dimensions?: string[];
+    filters?: FilterExpression[];
+    certified?: boolean;
+    owner?: string;
+    category?: string;
+    tags?: string[];
+    synonyms?: string[];
+    relatedMetrics?: string[];
+    timeDimension?: string;
+    defaultGranularity?: DataGranularity;
+    targets?: MetricTarget[];
+    thresholds?: MetricThreshold[];
+}
+/** Metric target */
+export interface MetricTarget {
+    name: string;
+    value: number;
+    period?: string;
+    comparison?: 'above' | 'below' | 'at';
+}
+/** Metric threshold */
+export interface MetricThreshold {
+    name: string;
+    operator: 'greaterThan' | 'lessThan' | 'between';
+    value?: number;
+    minValue?: number;
+    maxValue?: number;
+    severity: 'info' | 'warning' | 'critical';
+    color?: string;
+}
+/** Dimension definition */
+export interface DimensionDefinition {
+    id: string;
+    name: string;
+    displayName?: string;
+    description?: string;
+    table?: string;
+    column?: string;
+    expression?: string;
+    dataType: AnalyticsDataType;
+    semanticType?: SemanticType;
+    hierarchy?: DimensionHierarchy;
+    certified?: boolean;
+    owner?: string;
+    category?: string;
+    tags?: string[];
+    synonyms?: string[];
+}
+/** Dimension hierarchy */
+export interface DimensionHierarchy {
+    name: string;
+    levels: HierarchyLevel[];
+}
+/** Hierarchy level */
+export interface HierarchyLevel {
+    name: string;
+    column: string;
+    ordinal: number;
+    cardinality?: number;
+}
+/** Metric category */
+export interface MetricCategory {
+    id: string;
+    name: string;
+    description?: string;
+    parent?: string;
+    icon?: string;
+    color?: string;
+}
+/** Metrics governance */
+export interface MetricsGovernance {
+    certificationRequired?: boolean;
+    approvalWorkflow?: ApprovalWorkflow;
+    changeTracking?: boolean;
+    auditLog?: boolean;
+}
+/** Approval workflow */
+export interface ApprovalWorkflow {
+    enabled?: boolean;
+    approvers?: string[];
+    requireAllApprovers?: boolean;
+    autoApproveOwner?: boolean;
+}
+/** Glossary configuration */
+export interface GlossaryConfig {
+    enabled?: boolean;
+    categories?: GlossaryCategory[];
+    governance?: GlossaryGovernance;
+}
+/** Glossary */
+export interface Glossary {
+    id: string;
+    name: string;
+    description?: string;
+    terms: GlossaryTerm[];
+    categories: GlossaryCategory[];
+}
+/** Glossary term */
+export interface GlossaryTerm {
+    id: string;
+    name: string;
+    displayName?: string;
+    definition: string;
+    description?: string;
+    category?: string;
+    synonyms?: string[];
+    relatedTerms?: string[];
+    linkedObjects?: LinkedObject[];
+    owner?: string;
+    steward?: string;
+    status: 'draft' | 'review' | 'approved' | 'deprecated';
+    certified?: boolean;
+    created?: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    tags?: string[];
+}
+/** Linked object */
+export interface LinkedObject {
+    type: 'table' | 'column' | 'metric' | 'dimension' | 'report' | 'dashboard';
+    id: string;
+    name: string;
+    dataSource?: string;
+}
+/** Glossary category */
+export interface GlossaryCategory {
+    id: string;
+    name: string;
+    description?: string;
+    parent?: string;
+    icon?: string;
+    color?: string;
+}
+/** Glossary governance */
+export interface GlossaryGovernance {
+    approvalRequired?: boolean;
+    workflow?: ApprovalWorkflow;
+    changeTracking?: boolean;
+}
+/** Analytics collaboration configuration */
+export interface AnalyticsCollaborationConfig {
+    enabled?: boolean;
+    comments?: CommentConfig;
+    sharing?: AnalyticsSharingConfig;
+    notifications?: NotificationConfig;
+    activity?: ActivityConfig;
+}
+/** Comment config */
+export interface CommentConfig {
+    enabled?: boolean;
+    mentions?: boolean;
+    reactions?: boolean;
+    threads?: boolean;
+    attachments?: boolean;
+}
+/** Analytics sharing config */
+export interface AnalyticsSharingConfig {
+    enabled?: boolean;
+    levels?: SharingLevel[];
+    externalSharing?: boolean;
+    linkSharing?: boolean;
+    embedding?: boolean;
+}
+/** Notification config */
+export interface NotificationConfig {
+    enabled?: boolean;
+    email?: boolean;
+    inApp?: boolean;
+    slack?: boolean;
+    teams?: boolean;
+}
+/** Activity config */
+export interface ActivityConfig {
+    enabled?: boolean;
+    tracking?: boolean;
+    history?: boolean;
+    retentionDays?: number;
+}
+/** Collaboration session */
+export interface AnalyticsCollaborationSession {
+    id: string;
+    objectType: 'exploration' | 'story' | 'dashboard' | 'metric';
+    objectId: string;
+    participants: SessionParticipant[];
+    comments: Comment[];
+    activity: ActivityEntry[];
+    started?: Date;
+    ended?: Date;
+}
+/** Session participant */
+export interface SessionParticipant {
+    userId: string;
+    name: string;
+    avatar?: string;
+    role: 'owner' | 'editor' | 'viewer';
+    cursor?: CursorPosition;
+    selection?: SelectionRange;
+    online?: boolean;
+    lastActive?: Date;
+}
+/** Cursor position */
+export interface CursorPosition {
+    x: number;
+    y: number;
+    element?: string;
+}
+/** Selection range */
+export interface SelectionRange {
+    start: Position;
+    end: Position;
+    element?: string;
+}
+/** Comment */
+export interface Comment {
+    id: string;
+    text: string;
+    author: string;
+    authorName?: string;
+    created: Date;
+    modified?: Date;
+    resolved?: boolean;
+    resolvedBy?: string;
+    resolvedAt?: Date;
+    parentId?: string;
+    replies?: Comment[];
+    mentions?: string[];
+    reactions?: Reaction[];
+    position?: CommentPosition;
+    attachments?: Attachment[];
+}
+/** Reaction */
+export interface Reaction {
+    type: string;
+    users: string[];
+    count: number;
+}
+/** Comment position */
+export interface CommentPosition {
+    type: 'element' | 'coordinates' | 'range';
+    target?: string;
+    x?: number;
+    y?: number;
+    start?: number;
+    end?: number;
+}
+/** Attachment */
+export interface Attachment {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    url: string;
+}
+/** Activity entry */
+export interface ActivityEntry {
+    id: string;
+    type: ActivityType;
+    user: string;
+    userName?: string;
+    timestamp: Date;
+    details?: Record<string, unknown>;
+    changes?: ChangeRecord[];
+}
+/** Activity type */
+export type ActivityType = 'created' | 'modified' | 'deleted' | 'shared' | 'viewed' | 'commented' | 'resolved' | 'exported' | 'scheduled' | 'executed';
+/** Change record */
+export interface ChangeRecord {
+    field: string;
+    oldValue?: unknown;
+    newValue?: unknown;
+}
+/** Usage analytics */
+export interface UsageAnalytics {
+    period: TimeRange;
+    summary: UsageSummary;
+    topUsers?: UserUsage[];
+    topContent?: ContentUsage[];
+    topQueries?: QueryUsage[];
+    trends?: UsageTrend[];
+}
+/** Usage summary */
+export interface UsageSummary {
+    totalUsers: number;
+    activeUsers: number;
+    totalQueries: number;
+    totalViews: number;
+    totalExports: number;
+    avgQueryTime: number;
+    dataProcessed: number;
+}
+/** User usage */
+export interface UserUsage {
+    userId: string;
+    userName?: string;
+    queries: number;
+    views: number;
+    exports: number;
+    lastActive: Date;
+}
+/** Content usage */
+export interface ContentUsage {
+    id: string;
+    name: string;
+    type: 'exploration' | 'story' | 'dashboard' | 'metric';
+    views: number;
+    uniqueUsers: number;
+    avgTimeSpent: number;
+    lastViewed: Date;
+}
+/** Query usage */
+export interface QueryUsage {
+    queryHash: string;
+    queryPattern?: string;
+    executionCount: number;
+    uniqueUsers: number;
+    avgDuration: number;
+    totalBytesScanned: number;
+}
+/** Usage trend */
+export interface UsageTrend {
+    date: Date;
+    users: number;
+    queries: number;
+    views: number;
+    dataProcessed: number;
+}
+/** Data certification */
+export interface DataCertification {
+    id: string;
+    objectType: 'table' | 'column' | 'metric' | 'dimension' | 'dataSource';
+    objectId: string;
+    objectName: string;
+    status: CertificationStatus;
+    level?: CertificationLevel;
+    certifiedBy?: string;
+    certifiedAt?: Date;
+    expiresAt?: Date;
+    notes?: string;
+    criteria?: CertificationCriterion[];
+    history?: CertificationHistory[];
+}
+/** Certification status */
+export type CertificationStatus = 'uncertified' | 'pending' | 'certified' | 'expired' | 'revoked';
+/** Certification level */
+export type CertificationLevel = 'bronze' | 'silver' | 'gold' | 'platinum';
+/** Certification criterion */
+export interface CertificationCriterion {
+    id: string;
+    name: string;
+    description?: string;
+    required: boolean;
+    passed: boolean;
+    checkedAt?: Date;
+    checkedBy?: string;
+    notes?: string;
+}
+/** Certification history */
+export interface CertificationHistory {
+    action: 'submitted' | 'approved' | 'rejected' | 'expired' | 'revoked';
+    timestamp: Date;
+    user: string;
+    notes?: string;
+    previousStatus?: CertificationStatus;
+}
+//# sourceMappingURL=self-service-analytics.d.ts.map