import * as AccordionPrimitive from '@radix-ui/react-accordion';
import { BadgeProps } from '../ui/badge';
import { ClassProp } from 'class-variance-authority/types';
import { default as default_2 } from 'react';
import * as React_2 from 'react';
import { VariantProps } from 'class-variance-authority';

declare function AccordionItem({ className, ...props }: React_2.ComponentProps<typeof AccordionPrimitive.Item>): React_2.JSX.Element;

export declare interface AIAnswerMessage extends BaseMessage {
    type: MessageType.ANSWER;
    role: 'ai';
    content: string;
    relatedArticles?: RelatedArticle[];
    discarded?: boolean;
    discardedMeta?: {
        reason: DiscardReason;
        suggestedAnswer?: string;
    };
    confidenceScore?: number;
}

declare type AnswerDiagnostics = {
    confidence_score: string;
    answer_generation_type?: AnswerGenerationType;
    query_context_relevance?: QueryContextRelevance;
    context_sufficiency?: ContextSufficiency;
    confidence_justification?: string;
    evidence_from_context?: EvidenceFromContext[];
};

declare type AnswerGenerationType = 'Direct Extraction' | 'Summarization' | 'Inference' | 'Combination' | 'Cannot Answer';

export declare interface Attachment {
    type: 'image' | string;
    url: string;
}

declare function Badge({ className, variant, ...props }: BadgeProps_2): React_2.JSX.Element;

declare interface BadgeProps_2 extends React_2.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
}

declare const badgeVariants: (props?: ({
    variant?: "default" | "disabled" | "destructive" | "success" | "warning" | null | undefined;
} & ClassProp) | undefined) => string;

declare interface BaseMessage {
    id: string;
    timestamp: Date;
    locale?: string;
    isFeedbackDialogOpen?: boolean;
    onFeedbackDialogChange?: (isOpen: boolean) => void;
}

declare type ContextSufficiency = 'Sufficient' | 'Partially Sufficient' | 'Insufficient';

/**
 * Convo component - A single conversation item in an accordion.
 * Displays conversation metadata and messages, with support for lazy loading.
 *
 * This is a presentational component - it receives messages and loading state as props
 * rather than managing fetching logic itself.
 */
export declare function Convo({ locale: localeOverride, value: queryId, question, timestamp, location, source, status, statusMessage, hasAttributes, onClick, className, score, ...props }: ConvoProps): default_2.JSX.Element;

export declare type ConvoProps = default_2.ComponentPropsWithRef<typeof AccordionItem> & Props;

/**
 * Convos component - Displays a list of conversations in an accordion.
 * Messages are always lazy loaded when accordion items are opened.
 *
 * @param convos - Array of conversation data
 * @param fetchMessages - Async function to fetch messages for a conversation
 */
export declare function Convos({ convos, fetchMessages, fetchAttributes, fetchAnswerDiagnostics, onDiscard, onApprove, }: ConvosProps): default_2.JSX.Element;

declare interface ConvosContextValue {
    fetchMessages: (conversationId: string) => Promise<MessageProps[]>;
    fetchAttributes: (conversationId: string) => Promise<Record<string, any>[]>;
    getMessages: (conversationId: string) => MessageProps[];
    isLoading: (conversationId: string) => boolean;
    handleFetchMessages: (conversationId: string) => void;
    locale?: string;
    fetchAnswerDiagnostics: (messageId: string) => Promise<AnswerDiagnostics>;
    onDiscard: (id: string, reason: DiscardReason, suggestedAnswer?: string) => Promise<void>;
    onApprove: (id: string) => Promise<void>;
}

declare interface ConvosProps {
    convos: ConvoProps[];
    fetchMessages: (conversationId: string) => Promise<MessageProps[]>;
    fetchAttributes: (conversationId: string) => Promise<Record<string, any>[]>;
    fetchAnswerDiagnostics: (messageId: string) => Promise<AnswerDiagnostics>;
    onDiscard: (id: string, reason: DiscardReason, suggestedAnswer?: string) => Promise<void>;
    onApprove: (id: string) => Promise<void>;
}

export declare function ConvosProvider({ children, value }: ConvosProviderProps): default_2.JSX.Element;

declare interface ConvosProviderProps {
    children: default_2.ReactNode;
    value: ConvosContextValue;
}

declare enum DiscardReason {
    INCORRECT_ANSWER = "incorrect_answer",
    HALLUCINATED_ANSWER = "hallucinated_answer",
    OVERSHARING = "oversharing",
    WRONG_ARTICLE_SURFACED = "wrong_article_surfaced",
    OTHER = "other"
}

export declare const EmptyConvos: ({ children }: {
    children: default_2.ReactNode;
}) => default_2.JSX.Element;

declare interface EvidenceFromContext {
    supporting_quote?: string;
    url?: string;
}

export declare enum Feedback {
    Positive = "positive",
    Negative = "negative"
}

export declare const isAction: (msg: MessageProps) => msg is UserActionMessage;

export declare const isAIAnswer: (msg: MessageProps) => msg is AIAnswerMessage;

export declare const isFeedback: (msg: MessageProps) => msg is UserFeedbackMessage;

export declare const isUserQuestion: (msg: MessageProps) => msg is UserQuestionMessage;

export declare function Message(props: MessageProps): default_2.JSX.Element;

export declare function MessageAttachmentImageThumbnails({ attachments }: {
    attachments: Attachment[];
}): default_2.JSX.Element;

export declare type MessageProps = AIAnswerMessage | UserQuestionMessage | UserFeedbackMessage | UserActionMessage;

export declare enum MessageType {
    ACTION = "action",
    FEEDBACK = "feedback",
    QUESTION = "question",
    ANSWER = "answer"
}

declare interface Props {
    locale?: string;
    question: string;
    timestamp: Date;
    location?: string;
    source?: Source;
    status?: default_2.ComponentProps<typeof StatusBadge>['variant'];
    statusMessage?: string;
    hasAttributes?: boolean;
    onClick?: () => void;
    score?: number;
}

declare type QueryContextRelevance = 'High' | 'Medium' | 'Low';

export declare interface RelatedArticle {
    id: string;
    title: string;
    url: string;
    score: number;
}

declare interface Source {
    name: string;
    color?: string;
}

export declare const StatusBadge: default_2.ForwardRefExoticComponent<Omit<BadgeProps, "variant"> & {
    variant?: default_2.ComponentPropsWithRef<typeof Badge>['variant'] | 'accepted';
    suffix?: default_2.ReactNode;
} & default_2.RefAttributes<HTMLSpanElement>>;

export declare function useConvosContext(): ConvosContextValue;

export declare interface UserActionMessage extends BaseMessage {
    type: MessageType.ACTION;
    role: 'user';
    content: string;
}

export declare interface UserFeedbackMessage extends BaseMessage {
    type: MessageType.FEEDBACK;
    role: 'user';
    content: string;
    feedback: Feedback;
}

export declare interface UserQuestionMessage extends BaseMessage {
    type: MessageType.QUESTION;
    role: 'user';
    content: string;
    attachments?: Attachment[];
    onlyShowAttachments?: boolean;
}

export { }