export type Id = string;
/**
 * History event types for the generic audit history UI.
 *
 * Backend returns raw values; frontend computes display representation.
 */
export type HistoryEventOperation = 'CREATE' | 'UPDATE' | 'DELETE';
export type HistoryChangeType = 'TEXT' | 'BOOLEAN' | 'RELATION' | 'DATE' | 'NUMBER' | 'LONG_TEXT' | 'UNKNOWN';
/**
 * A single field change in a history event.
 * Backend returns raw values as strings; frontend computes display.
 */
export interface HistoryValue {
    raw: string | null;
    display: string | null;
}
export interface HistoryChange {
    field: string;
    oldValue: HistoryValue | null;
    newValue: HistoryValue | null;
    type: HistoryChangeType;
}
/**
 * Actor information for a history event.
 * Only contains ID; frontend resolves names via host-provided maps.
 */
export interface HistoryActor {
    id: string;
    name: string | null;
}
export interface HistoryEntity {
    tableName: string;
    id: string;
    type: string;
    label: string | null;
}
export interface HistoryEvent {
    id: string;
    createdAt: string;
    /** Actor only has ID; frontend resolves name via user map */
    actor?: HistoryActor | null;
    operation: HistoryEventOperation;
    entity: HistoryEntity;
    actionName?: string | null;
    changes: HistoryChange[];
    transactionId?: number | null;
}
/**
 * A transaction groups multiple history events that occurred in the same database transaction.
 */
export interface HistoryEventTransaction {
    id: string;
    transactionId: number | null;
    createdAt: string;
    actor?: HistoryActor | null;
    events: HistoryEvent[];
}
/**
 * Presentation configuration for history rendering.
 * Allows host applications to provide custom labels and formatting.
 */
export interface HistoryPresentationConfig {
    /** Entity type labels (e.g., { task: { label: 'Task' } }) */
    entities?: Record<string, {
        label: string;
    }>;
    /** Field configuration for labels, types, and custom formatting */
    fields?: Record<string, {
        label: string;
        type?: HistoryChangeType;
        relationType?: string;
        booleanLabels?: {
            true: string;
            false: string;
        };
    }>;
    /** User ID to display name map for actor resolution */
    users?: Record<string, string>;
    /** Relation value resolution maps (field -> id -> display name) */
    resolvedValues?: Record<string, Record<string, string>>;
}
export interface Entity {
    __typename: string;
    id: Id;
    createdAt?: string;
    updatedAt?: string;
    deletedAt?: string;
}
export interface Ordered {
    id: string;
    rank: string;
}
export interface ActivityType extends Entity {
    name: string;
}
export interface TemplateDetails extends Entity, Ordered {
    name?: string;
    phases: Phase[];
    rules?: Rule[];
    order: number;
    updatedAt?: string;
    updatedBy?: string;
}
export interface Phase extends Entity, Ordered {
    name?: string;
    milestones: Milestone[];
    deadline?: string;
    active: boolean;
    color?: string;
}
export declare const milestoneStatus: {
    readonly todo: "todo";
    readonly done: "done";
    readonly archived: "archived";
};
export type MilestoneStatusKeys = keyof typeof milestoneStatus;
export type MilestoneStatus = (typeof milestoneStatus)[MilestoneStatusKeys];
export interface Milestone extends Entity, Ordered {
    name?: string;
    activities: Activity[];
    status?: MilestoneStatus;
    phase?: Phase;
    deadline?: string;
    important?: boolean;
    assignee?: User;
    color?: string;
    active: boolean;
}
export interface ActivityBase extends Entity, Ordered {
    name: string;
    description?: string;
    estimation?: number;
    important?: boolean;
    type?: ActivityType;
    activityType?: "standard" | "dev";
    milestone?: Milestone;
    dependingOn?: ActivityBase[];
    blocking?: ActivityBase[];
    attachments?: Attachment[];
    tasks?: Subtask[];
    slug?: string;
    blocked?: boolean;
}
export declare const durationTypes: {
    readonly months: "months";
    readonly weeks: "weeks";
    readonly days: "days";
};
export type DurationTypesKeys = keyof typeof durationTypes;
export type DurationTypes = (typeof durationTypes)[DurationTypesKeys];
export interface Activity extends ActivityBase {
    assignee?: User;
    status?: ActivityStatus;
    devStatus?: ActivityDevStatus;
    sprint?: Sprint;
    deadline?: string;
    project?: Project;
    comments?: Comment[];
    duration?: number;
    durationType?: DurationTypes;
    private: boolean;
    createdBy: User;
}
export interface AddActivityFeedPayload {
    name: string;
    rank: string;
    statusId: string;
    assigneeId?: Id;
    projectId?: Id;
    type?: "standard" | "dev";
    statusDevId?: Id;
    sprintId?: Id;
}
export interface ActivityFeed<K extends ActivityFeedStatus = ActivityFeedStatus> extends ActivityBase {
    project: {
        projectId: Id;
        name?: string;
    };
    active: boolean;
    milestoneId?: Id;
    phaseId?: Id;
    deadline?: string;
    assignee?: Id;
    comments?: Comment[];
    attachments?: Attachment[];
    feedStatus: (typeof activityFeedStatus)[K];
}
export interface Subtask extends Entity {
    name: string;
    assignee?: {
        id: Id;
    };
    isDone?: boolean;
}
export interface Comment extends Entity {
    author: User;
    message: string;
    createdAt: string;
    updatedAt?: string;
}
export interface FileLike extends Entity {
    id: Id;
    name: string;
    size: number;
    encoding: string;
    mimeType: string;
    url: string;
}
export interface Attachment extends FileLike {
    createdAt: string;
}
export interface ActivityStatus extends Entity {
    name: string;
}
export interface ActivityDevStatus extends Entity {
    name: string;
}
export interface AuditLog {
    id: number;
    schemaName: string;
    tableName: string;
    recordKey: string;
    foreignKey: string | null;
    changedForeignKey: string | null;
    operation: string;
    oldData: string | null;
    newData: string | null;
    actorUserId: string | null;
    actionName: string | null;
    transactionId: number;
    createdAt: string;
}
/**
 * @deprecated Use AuditLog instead
 */
export type ActivityHistory = AuditLog;
export interface Sprint extends Entity {
    number: number;
    label?: string;
    projectId: string;
    startDate: string;
    endDate: string;
    color?: string;
    active: boolean;
}
export interface SprintMilestone extends Entity {
    name: string;
    rank: string;
    important: boolean;
    color?: string;
}
export interface SprintPlanningUser {
    userId: string;
    fullName: string;
    plannedManDays: number;
}
export interface SprintPlanningData {
    projectId: string;
    startDate: string;
    endDate: string;
    plannedManDays: number;
    remainingPlannedManDays: number;
    userIds?: string[];
    users: SprintPlanningUser[];
}
export declare const activityFeedStatus: {
    readonly future: "future";
    readonly this_month: "this_month";
    readonly this_week: "this_week";
    readonly today: "today";
    readonly done: "done";
};
export type ActivityFeedStatusKeys = keyof typeof activityFeedStatus;
export type ActivityFeedStatus = (typeof activityFeedStatus)[ActivityFeedStatusKeys];
export declare const ruleComparators: {
    readonly BEFORE: "before";
    readonly AFTER: "after";
};
export type RuleComparatorKeys = keyof typeof ruleComparators;
export type RuleComparator = (typeof ruleComparators)[RuleComparatorKeys];
export declare const ruleTriggerTypes: {
    readonly START: "start";
    readonly end: "end";
};
export type RuleTriggerTypeKeys = keyof typeof ruleTriggerTypes;
export type RuleTriggerTypes = (typeof ruleTriggerTypes)[RuleTriggerTypeKeys];
export declare const ruleDurationUnits: {
    readonly DAYS: "days";
    readonly WEEKS: "weeks";
    readonly MONTHS: "months";
};
export type RuleDurationUnitKeys = keyof typeof ruleDurationUnits;
export type RuleDurationUnits = (typeof ruleDurationUnits)[RuleDurationUnitKeys];
export interface Rule {
    id: Id;
    itemType?: TemplateItemType;
    subItemId?: Id;
    comparator?: RuleComparator;
    trigger?: RuleTriggerTypes;
    deadline?: string;
    startDate?: string;
    duration?: number;
    durationUnit?: RuleDurationUnits;
}
export interface User {
    id: Id;
    firstName?: string;
    lastName?: string;
    avatarUrl?: string;
}
export declare const templateItemType: {
    readonly TEMPLATES: "templates";
    readonly PHASES: "phases";
    readonly MILESTONES: "milestones";
    readonly ACTIVITIES: "activities";
    readonly TASKS: "tasks";
};
export declare enum TemplateItemTypeEnum {
    PHASES = "phases",
    MILESTONES = "milestones",
    ACTIVITIES = "activities"
}
export type TemplateItemTypeKeys = keyof typeof templateItemType;
export type TemplateItemType = (typeof templateItemType)[TemplateItemTypeKeys];
export interface UpdateTemplateDetailsPayload {
    id: Id;
    name?: string;
    phases?: Phase[];
    rules?: Rule[];
    order?: number;
}
export interface AddItemPayload {
    type: TemplateItemType;
    templateId: Id;
    phaseId?: Id;
    milestoneId?: Id;
    activityId?: Id;
    item: AddPhasePayload | AddMilestonePayload | AddActivityPayload | AddSubtaskPayload;
}
export interface AddPhasePayload {
    name: string;
    rank: string;
    projectId?: string;
    deadline?: string;
}
export interface BulkMutationCallbacks {
    onSuccess: () => void;
    onError: () => void;
}
export interface BulkAddPhasePayload extends BulkMutationCallbacks {
    projectId: Id;
    phases: Array<{
        name: string;
        rank: string;
    }>;
}
export interface BulkAddMilestonePayload extends BulkMutationCallbacks {
    phaseId: Id;
    milestones: Array<{
        name: string;
        rank: string;
    }>;
}
export interface BulkAddActivityPayload extends BulkMutationCallbacks {
    projectId: Id;
    phaseId: Id;
    milestoneId: Id;
    activities: Array<{
        name: string;
        rank: string;
    }>;
}
export interface AddMilestonePayload {
    name: string;
    rank: string;
    phaseId: string;
    deadline?: string;
}
export interface AddActivityPayload {
    milestoneId: Id;
    name: string;
    rank: Id;
    projectId?: Id;
}
export interface UpdateMilestonePayload {
    id: Id;
    phaseId?: Id;
    rank?: string;
    name?: string;
    activities?: Activity[];
    rules?: Rule[];
    deadline?: string | null;
    assigneeId?: Id;
    important?: Boolean;
    color?: string;
}
export interface UpdateItemPayload<T extends TemplateItemType> {
    itemType: T;
    id: Id;
    templateId: Id;
    data: UpdateItemPayloadDataTypes[T];
}
export interface UpdatePhasePayload {
    id: Id;
    name?: string;
    milestones?: Milestone[];
    rules?: Rule[];
    rank?: string;
    deadline?: string;
}
export type UpdateItemPayloadDataTypes = {
    [TemplateItemTypeEnum.ACTIVITIES]: UpdateActivityPayload;
    [TemplateItemTypeEnum.MILESTONES]: UpdateMilestonePayload;
    [TemplateItemTypeEnum.PHASES]: UpdatePhasePayload;
};
export type UpdateItemPayloadData<T extends TemplateItemTypeEnum> = UpdateItemPayloadDataTypes[T];
export interface MoveItemPayload {
    id: Id;
    rank: string;
}
export interface RemoveItemPayload<T extends TemplateItemType> {
    itemType: T;
    templateId: Id;
    phaseId?: Id;
    milestoneId?: Id;
    activityId?: Id;
    data: {
        id: Id;
        name?: string;
    };
}
export interface RemoveMilestonePayload {
    id: Id;
    phaseId: Id;
}
export interface RemoveActivityPayload {
    id: Id;
}
export interface AddSubtaskPayload {
    activityId: Id;
    name: string;
}
export interface StartTimerPayload {
    activityId: Id;
    activityName: string;
    project?: string;
    projectId?: string;
    activitySlug?: string;
}
export interface UpdateActivityPayload {
    id: Id;
    name?: string;
    rules?: Rule[];
    tasks?: Subtask[];
    description?: string;
    estimation?: number;
    important?: boolean;
    dependingOn?: Id[];
    blocking?: Id[];
    dependingMilestones?: Id[];
    type?: "standard" | "dev";
    rank?: string;
    statusId?: string;
    statusDevId?: string;
    deadline?: string | null;
    assigneeId?: Id | null;
    projectId?: Id;
    milestoneId?: Id;
    private?: boolean;
    sprintId?: Id | null;
    blocked?: boolean;
}
export interface AddRulePayload {
    templateId: Id;
}
export interface UpdateRulePayload extends Rule {
}
export interface updateTemplateRulePayload {
    templateId: Id;
    payload: UpdateRulePayload;
}
export interface RemoveRulePayload {
    templateId: Id;
    id: Id;
}
export declare const listUpdateTypes: {
    readonly add: "add";
    readonly remove: "remove";
    readonly moved: "moved";
};
export type ListUpdateTypesKeys = keyof typeof listUpdateTypes;
export type ListUpdateTypes = (typeof listUpdateTypes)[ListUpdateTypesKeys];
export type FeedListUpdateType = {
    element: Activity;
};
export type FeedListUpdateAdded = {
    added: {
        element: Activity;
        newIndex: number;
    };
};
export type FeedListUpdateRemoved = {
    removed: {
        element: Activity;
        oldIndex: number;
    };
};
export type FeedListUpdateMoved = {
    moved: {
        element: Activity;
        newIndex: number;
        oldIndex: number;
    };
};
export type FeedListUpdateUnion = FeedListUpdateAdded | FeedListUpdateRemoved | FeedListUpdateMoved;
export type FeedListUpdates = {
    [listUpdateTypes.add]: FeedListUpdateAdded;
    [listUpdateTypes.remove]: FeedListUpdateRemoved;
    [listUpdateTypes.moved]: FeedListUpdateMoved;
};
export type FeedListUpdate<K extends ListUpdateTypesKeys> = FeedListUpdates[K];
export interface UpdateFeedActivitiesPayload<T extends ActivityFeedStatus> {
    payload: {
        status: T;
        activities: ActivityFeed<T>[];
    };
}
export interface ChangeFeedActivitiesChange {
    change: FeedListUpdateUnion;
}
export type ChangeFeedActivitiesPayload = ChangeFeedActivitiesChange & {
    status: ActivityStatus;
};
export type AddFeedActivityPayload = {
    status: ActivityStatus;
};
export type Project = {
    id: string;
    name?: string;
    phases?: Phase[];
    architectureImage?: Image;
    estimationUnit: EstimationUnit;
};
export declare enum EstimationUnit {
    HOURS = "hours",
    DAYS = "days"
}
export type Image = {
    url: string;
    name: string;
};
export declare const feedFilterTypes: {
    readonly project: "projectId";
    readonly assignee: "assigneeId";
    readonly sprint: "sprintId";
    readonly milestone: "milestoneId";
};
export type FeedFilterTypeKeys = keyof typeof feedFilterTypes;
export type FeedFilterType = (typeof feedFilterTypes)[FeedFilterTypeKeys];
export type UpdateFeedFilterPayload = {
    type: FeedFilterType;
    values: Array<Id | string>;
};
export type FeedFilters = Record<FeedFilterType, Id[]>;
export type UdpateFeedActivityData = {
    id: Id;
    phaseId?: Id;
    milestoneId?: Id;
    rank: number;
    name?: string;
    rules?: Rule[];
    tasks?: Subtask[];
    description?: string;
    estimation?: number;
    important?: boolean;
    dependingOn?: Id[];
    blocking?: Id[];
    dependingMilestones?: Id[];
    type?: string;
    feedStatus: ActivityFeedStatus;
};
export type UpdateFeedActivityPayload = {
    itemType: typeof templateItemType.ACTIVITIES;
    id: Id;
    projectId?: Id;
    data: UdpateFeedActivityData;
};
export type UdpateProjectActivityData = {
    id: Id;
    phaseId: Id;
    milestoneId: Id;
    rank: string;
    name?: string;
    rules?: Rule[];
    tasks?: Subtask[];
    description?: string;
    estimation?: number;
    important?: boolean;
    dependingOn?: Id[];
    blocking?: Id[];
    dependingMilestones?: Id[];
    type?: string;
};
export type UpdateSubtaskFieldPayload = {
    id: Id;
    name?: string;
    assigneeId?: Id;
    isDone?: boolean;
};
export type MultiselectOption = {
    label: string;
    value: Id;
};
export type MultiselectOptionTagProps<T extends MultiselectOption = MultiselectOption> = {
    option: T;
    handleTagRemove: (option: T, e: Event) => void;
};
export type AddFilesPayload = {
    activityId: Id;
    files: File[];
};
export type RemoveFilePayload = {
    activityId: Id;
    file: Attachment;
};
export type AddCommentPayload = {
    activityId: Id;
    authorId: Id;
    message: string;
    mentionedUserIds: Id[];
};
export type UpdateCommentPayload = {
    id: Id;
    message: string;
    mentionedUserIds: Id[];
};
export type RemoveCommentPayload = {
    id: Id;
};
export type ApplyTemplatePayload = {
    templateId: Id;
    projectId: Id;
};
export type SaveTemplatePayload = {
    templateName: string;
    rank: Id;
    phaseIds: Id[];
};
export type TimeTracking = {
    timeSpent: number;
};