export type RuleSetCategory = 'Global' | 'Genre' | 'Custom';
export type RuleSetItem = {
    ruleSetId: string;
    ruleSetName: string;
    ruleSetDesc: string;
    ruleCount: number;
};
export type AllRuleSetsResponse = {
    globalRuleSet: RuleSetItem[];
    genreRuleSet: RuleSetItem[];
    customRuleSet: RuleSetItem[];
};
/** Alias for library component compatibility */
export type RuleSets = AllRuleSetsResponse;
/**
 * Represents a single station in the stations list.
 */
export type StationItem = {
    /** Unique identifier for the station (maps to ruleSetId) */
    stationId: string;
    /** Global unique identifier for the station (from station autocomplete) */
    stationGuid?: string;
    /** Display name of the station */
    stationName: string;
    /** Description of the station */
    stationDescription: string;
    /** Number of rules configured for this station */
    rulesCount: number;
};
/**
 * Scheduling configuration for a variant.
 * Contains separation times and toggle settings.
 */
export type SchedulingConfig = {
    /** Order separation time in seconds */
    order_global_min_separation_seconds?: number;
    /** Advertiser separation time in seconds */
    advertiser_global_min_separation_seconds?: number;
    /** Whether to respect inventory codes */
    respect_inventory_code?: boolean;
    /** Whether to respect break codes */
    respect_break_code?: boolean;
};
/**
 * Configuration object for a variant containing scheduling settings.
 */
export type VariantConfiguration = {
    scheduling_config?: SchedulingConfig;
};
export type RuleCondition = {
    text: string;
    source?: string;
    link?: string;
};
/**
 * Represents a single variant of a rule.
 * Each rule can have multiple variants with different conditions and configurations.
 * Library-ready: fully typed and documented.
 */
export type RuleVariant = {
    /** Unique identifier for the variant */
    variantId: string;
    /** Description of what this variant does */
    description: string;
    /** Conditions under which this variant applies (joined by \" OR \") */
    whenToApply: string;
    /** Conditions under which this variant should NOT apply (joined by \" OR \") */
    whenNotToApply: string;
    /** Configuration settings for this variant (scheduling config, etc.) */
    configuration?: VariantConfiguration;
    /** Data source reference for this variant */
    dataSource?: {
        type: string;
        ref: string;
        tag: string;
    };
    variantType: string;
    /** Inheritance chain for this variant (e.g., [\"Global\", \"Genre\", \"Station\"]) */
    inheritance?: string[];
    /** Link ID for this variant */
    link_id?: string;
    /** Whether this variant is linked to another variant */
    isLinked?: boolean;
    /** Name of the user who created this variant */
    createdBy?: string;
    /** ISO 8601 datetime when this variant was created */
    createdAt?: string;
    /** Name of the user who last updated this variant */
    updatedBy?: string;
    /** ISO 8601 datetime when this variant was last updated */
    updatedAt?: string;
    /** Whether the user has accepted the risk for this variant's gaps */
    is_user_accepted_risk?: boolean;
    is_enabled?: boolean;
    isOverridden?: boolean | null;
    approvalStatus?: string;
};
/**
 * Represents a rule definition which can contain multiple variants.
 * Library-ready: supports both new variants structure and legacy flat structure.
 */
export type RuleDefinition = {
    /** Unique identifier for the rule */
    ruleId: string;
    /** Title/name of the rule */
    ruleTitle: string;
    /** Array of variants for this rule */
    variants?: RuleVariant[];
    /** Unique ID for internal use */
    id?: string;
    is_user_accepted_risk?: boolean;
    has_accepted_risk?: string;
    user_accepted_risk_at?: string;
    /** @deprecated Use variants[].description instead */
    ruleDesc?: string;
    /** @deprecated Use variants[].whenToApply instead */
    whenToApply?: string;
    /** @deprecated Use variants[].whenNotToApply instead */
    whenNotToApply?: string;
    /** @deprecated Use variants[].configuration instead */
    configuration?: VariantConfiguration;
    /** @deprecated Use variants[].dataSource instead */
    dataSource?: {
        type: string;
        ref: string;
        tag: string;
    };
    /** @deprecated Use variants[].inheritance instead */
    inheritance?: string[];
};
export type RuleSetDetailsResponse = {
    ruleSetName: string;
    ruleSetDesc: string | null;
    created_at: string;
    updated_at: string | null;
    created_by: string;
    updated_by: string | null;
    [key: string]: RuleDefinition[] | string | null;
};
export type ChangeLogItem = {
    type: 'null' | 'edited' | 'add' | 'edit' | 'remove';
    text: string;
    scope: string;
};
export type OverrideHistoryField = {
    changeLog: ChangeLogItem[];
};
export type OverrideHistoryResponse = {
    ruleDescription: OverrideHistoryField;
    wta: OverrideHistoryField;
    wnta: OverrideHistoryField;
};
export type RuleTier = {
    id: string;
    name: string;
    description: string;
    ruleCount: number;
    isOpen: boolean;
    rules: RuleDefinition[];
};
export type CreateRuleSetPayload = {
    ruleSetType: string;
    ruleSetName: string;
    ruleSetDesc: string;
};
export type UpdateDescriptionPayload = {
    desc: string;
};
export type UpdateDescriptionResponse = {
    enhancedDesc: string;
};
export type ChatResponseRequest = {
    name: string;
    organizationName: string;
    prompt: string;
    overrideAgentConfig: Record<string, unknown>;
    metadata: Record<string, unknown>;
    useAgent: {
        agent_name: string;
        arguments: {
            user_query: string;
        };
    };
};
export type TreeNodeType = 'GLOBAL' | 'SCOPE' | 'SUBSCOPE' | 'Custom';
export interface NodeMetrics {
    learningsCount: number;
    stationsCount?: number;
}
export interface ScopeTreeNode {
    id: string;
    name: string;
    type: TreeNodeType;
    metrics: NodeMetrics;
    children: ScopeTreeNode[];
}
export interface ScopesTreeResponse {
    data: ScopeTreeNode | null;
}
export interface TreeSectionConfig {
    id: string;
    label: string;
    icon: any;
    badgeKey?: keyof NodeMetrics;
    /**
     * Optional visibility check.
     * If not provided, section is visible for all nodes.
     */
    isVisible?: (node: ScopeTreeNode, depth: number) => boolean;
}
export interface NodeTypeConfig {
    type: string;
    label: string;
    addChildLabel?: string;
    addChildType?: string;
}
export interface StationData {
    stationId: string;
    stationName: string;
    stationDesc: string;
    learningsCount: number;
}
export interface StationsResponse {
    data: StationData[];
}
export interface Tier {
    tier_id: string;
    tier_name: string;
    tier_priority: number | null;
}
//# sourceMappingURL=types.d.ts.map