import { CommentAccessMode, CommentVisibilityOptionType } from "../../utils/enums";
import { BaseMetadata } from "./base-metadata.data.model";
import { CommentVisibilityType } from "./comment-actions.data.model";
import { Comment } from "./comment.data.model";
import { CursorPosition } from "./cursor-position.data.model";
import { CustomAnnotationDropdownItem } from "./custom-chip-dropdown.data.model";
import { CustomCategory, CustomPriority, CustomStatus } from "./custom-filter.data.model";
import { Location } from "./location.model";
import { PageInfo } from "./page-info.model";
import { SuggestionData } from "./suggestion.data.model";
import { TargetElement } from "./target-element.data.model";
import { TargetTextRange } from "./target-text-range.data.model";
import { User } from "./user.data.model";
import { CommentAnnotationViews } from "./views.data.model";
export interface CommentAnnotationVisibilityConfig {
    type: CommentVisibilityType;
    organizationId?: string;
    /** Organization IDs for 'organizationPrivate' visibility — mirrors CommentVisibilityConfig.organizationIds (display-only). */
    organizationIds?: string[];
    /**
     * User IDs that can see the comment (display-only mirror of the self tokens in
     * `context.accessFields`). For non-public comments this ALWAYS includes the author's
     * userId, reflecting the author self-token invariant (AC-002).
     */
    userIds?: string[];
}
/**
 * Structured result produced by an AI agent for a comment annotation.
 * Read-only from the SDK's perspective — written upstream by the agent.
 */
export interface AgentResult {
    /** Short, bold headline rendered at the top of the agent suggestion card. */
    title?: string;
}
/**
 * Identity + output of the AI agent that authored a comment annotation.
 * Present on annotations created by an agent. The agent-suggestion UI renders
 * iff `agent` is present AND `type === 'suggestion'` (and the viewer is admin).
 *
 * `agentFields` mirrors the Firestore query field used by
 * `CommentRequestQuery.agentFields` (see comment-actions.data.model.ts).
 */
export interface AgentData {
    /** Canonical display name of the agent (card header). */
    agentName?: string;
    /** Legacy display name of the agent (card header); superseded by `agentName`. */
    name?: string;
    /** Avatar URL for the agent (card header); falls back to a default icon. */
    avatar?: string;
    /** Structured agent output (title, …). */
    result?: AgentResult;
    /** Queryable agent attributes. */
    agentFields?: string[];
}
export declare class CommentAnnotation {
    /**
     * Unique identifier for the comment pin annotation.
     *
     * Auto generated.
     */
    annotationId: string;
    /**
     * Annotation number for the comment pin annotation.
     *
     * Auto generated.
     */
    annotationNumber?: number;
    visibilityConfig?: CommentAnnotationVisibilityConfig;
    /**
     * This is the list of all comments part of this annotation.
     *
     */
    comments: Comment[];
    /**
     * The list of categories that this comment pin annotation belongs to.
     */
    commentCategories: CustomCategory[];
    /**
     * The user who created this comment pin annotation.
     *
     */
    from: User;
    /**
     * Color used for the comment pin annotation.
     *
     */
    color?: string;
    /**
     * @deprecated
     * Whether the comment annotation is marked resolved.
     *
     */
    resolved?: boolean;
    /**
     * @deprecated
     * Whether the comment annotation is marked as in progress.
     *
     */
    inProgress?: boolean;
    /**
     * Timestamp when the comment annotation was last updated.
     *
     * Auto generated.
     */
    lastUpdated?: any;
    /**
     * Timestamp when the comment annotation was created.
     *
     * Auto generated.
     */
    createdAt?: any;
    /**
     * Comment annotation's position on the X axis.
     *
     * Auto generated.
     */
    positionX?: number;
    /**
     * Comment annotation's position on the Y axis.
     *
     * Auto generated.
     */
    positionY?: number;
    /**
     * User’s screen width.
     *
     * Auto generated.
     */
    screenWidth?: number;
    /**
     * User’s screen height.
     *
     * Auto generated.
     */
    screenHeight?: number;
    /**
     * User’s screen scroll height.
     *
     * Auto generated.
     */
    screenScrollHeight?: number;
    /**
    * User’s screen scroll height.
    *
    * Auto generated.
    */
    screenScrollTop?: number;
    /**
     * Xpath of the element that was clicked.
     *
     * Auto generated.
     */
    taggedElementPath?: string;
    /**
     * Xpath of the element that was clicked.
     *
     * Auto generated.
     */
    taggedElementRect?: any;
    /**
     * Target element of comment annotation
     */
    targetElement?: TargetElement | null;
    /**
     * Target element id provided by user
     */
    targetElementId?: string | null;
    position?: CursorPosition | null;
    /**
     * Unique document params id generated from provided document params
     * @deprecated `documentParamsId` is deprecated and will be removed in next release, use `locationId` instead.
     */
    documentParamsId?: number | null;
    /**
     * Set document params to identify user on sub document
     * @deprecated `documentParams` is deprecated and will be removed in next release, use `location` instead.
     */
    documentParams?: Location | null;
    /**
     * Unique location id generated from provided location
     */
    locationId?: number | null;
    /**
     * Set location to identify user on sub document
     */
    location?: Location | null;
    type?: string;
    commentType?: string;
    /**
     * Origin of the annotation. `'agent'` indicates the annotation was authored by
     * an AI agent (drives the blue pin marker, agent identity header and blue text
     * highlight). Absent / any other value indicates a regular user comment.
     */
    sourceType?: string;
    metadata?: CommentMetadata;
    /**
     * Selected text range of comment annotation
     */
    targetTextRange?: TargetTextRange | null;
    /**
     * Set `true` to set text comment annotation on all the text content of provided target element using `targetElementId`
     */
    selectAllContent?: boolean;
    approved?: boolean;
    status: CustomStatus;
    /**
     * User id of the user who updated the status of the comment annotation
     */
    statusUpdatedByUserId?: string | null;
    /**
     * To maintain index of current annotation in available list of annotations
     * It will start from 1, so no need to add 1 in that.
     */
    annotationIndex?: number;
    pageInfo?: PageInfo;
    assignedTo?: User;
    priority?: CustomPriority;
    ghostComment?: GhostComment | null;
    /**
     * Connected area annotation id of comment annotation
     */
    areaAnnotationId?: string;
    /**
     * Custom context data provided by the user
     */
    context?: any;
    /**
     * Context id generated from context data
     */
    contextId?: string;
    iam: CommentIAMConfig;
    isPageAnnotation?: boolean;
    targetInlineCommentElementId?: string;
    inlineCommentSectionConfig?: InlineCommentSectionConfig;
    customList?: CustomAnnotationDropdownItem[];
    subscribedUsers?: CommentAnnotationSubscribedUsers;
    unsubscribedUsers?: CommentAnnotationUnsubscribedUsers;
    subscribedGroups?: CommentAnnotationSubscribedGroups;
    resolvedByUserId?: string | null;
    resolvedByUser?: User | null;
    multiThreadAnnotationId?: string;
    isDraft?: boolean;
    sourceId?: string;
    views?: CommentAnnotationViews;
    viewedByUserIds?: string[];
    viewedBy?: User[];
    unread?: boolean;
    /**
     * SDK-managed suggestion data. Present iff type === 'suggestion'.
     * Customer code must not write to this directly — use the SuggestionElement API.
     *
     * See docs/suggestions-api-contract.md for the full storage model.
     */
    suggestion?: SuggestionData;
    /**
     * AI agent identity + output. Present on agent-authored annotations.
     * Read-only from the SDK; written upstream by the agent.
     * See specs/agent-suggestion-comment-ui/spec.md (INV-001).
     */
    agent?: AgentData;
    /**
     * Server-derived set of all user IDs involved in this annotation
     * (subscribed + unsubscribed participants). Written upstream; read-only
     * from the SDK.
     */
    involvedUserIds?: string[];
    /**
     * Server-derived set of user IDs @mentioned across this annotation's
     * comments. Written upstream; read-only from the SDK.
     */
    mentionedUserIds?: string[];
}
export declare class GhostComment {
    targetElement?: TargetElement | null;
    message?: string;
    type?: string;
    /**
     * To check if comment is from same device group or not, device groups are ['mobile', 'tablet'] and ['desktop', 'monitor']
     */
    isSameGroup?: boolean;
}
export declare class CommentOnElementConfig {
    targetElement?: {
        targetText?: string;
        occurrence?: number;
        elementId?: string;
        selectAllContent?: boolean;
    };
    commentData?: {
        commentText: string;
        commentHtml?: string;
        status: string;
        from: any;
        replaceContentHtml?: string;
        replaceContentText?: string;
    }[];
    status?: string;
    context?: any;
    openComment?: boolean;
    sourceId?: string;
}
export declare class CommentIAMConfig {
    accessMode?: CommentAccessMode;
}
export declare class CommentMetadata extends BaseMetadata {
    [key: string]: any;
}
export declare class CommentSelectionChangeData {
    selected: boolean;
    annotation: CommentAnnotation;
}
export declare class VisibilityOptionClickedData {
    annotationId: string;
    visibility: CommentVisibilityOptionType;
    users?: any[];
}
export declare class InlineCommentSectionConfig {
    id: string;
    name?: string;
}
export declare class ManualCommentAnnotationConfig {
    context?: any;
    location?: Location;
}
export declare class CommentAnnotationSubscribedUsers {
    [userIdHash: string]: {
        user: User;
        type: 'manual' | 'auto';
    };
}
export declare class CommentAnnotationUnsubscribedUsers {
    [userIdHash: string]: {
        user: User;
        type: 'manual' | 'auto';
    };
}
export declare class CommentAnnotationSubscribedGroups {
    [groupId: string]: {
        type: 'manual' | 'auto';
    };
}
export declare class UpdateContextConfig {
    merge?: boolean;
}
export interface ContextOptions {
    partialMatch?: boolean;
}
