import { type Habit as ToduHabit, HabitFilter as ToduHabitFilter, HabitStreak as ToduHabitStreak, IntegrationBindingFilter as ToduIntegrationBindingFilter, RecurringFilter as ToduRecurringFilter, RecurringTemplate as ToduRecurringTemplate, TaskStatus as ToduTaskStatus } from "@todu/core";
import type { HabitCheckResult, HabitDetail, HabitFilter, HabitStreak, HabitSummary } from "../../domain/habit";
import type { ApprovalItem, ApprovalListFilter } from "../../domain/approval";
import type { NoteFilter, NoteSummary } from "../../domain/note";
import type { RecurringFilter, RecurringTemplateDetail, RecurringTemplateSummary } from "../../domain/recurring";
import type { ActorSummary } from "../../domain/actor";
import type { ProjectSummary, TaskComment, TaskDetail, TaskFilter, TaskId, TaskPriority, TaskStatus, TaskSummary } from "../../domain/task";
import type { AddHabitNoteInput, CreateHabitInput, DeleteHabitResult, UpdateHabitInput } from "../habit-service";
import type { CreateIntegrationBindingInput, IntegrationBinding, IntegrationBindingFilter, IntegrationBindingStatus, UpdateIntegrationBindingInput } from "../project-integration-service";
import type { CreateProjectInput, DeleteProjectResult, UpdateProjectInput as UpdateLocalProjectInput } from "../project-service";
import type { CreateRecurringInput, DeleteRecurringResult, UpdateRecurringInput } from "../recurring-service";
import type { AddTaskCommentInput, CreateTaskInput, DeleteTaskResult, MoveTaskInput, MoveTaskResult, UpdateTaskInput } from "../task-service";
import type { ToduDaemonConnection, ToduDaemonConnectionError } from "./daemon-connection";
import type { ToduDaemonEventListener, ToduDaemonEventName, ToduDaemonSubscription } from "./daemon-events";
export type ToduDaemonClientErrorCode = "not-found" | "validation" | "conflict" | "precondition-failed" | "unavailable" | "timeout" | "internal";
export declare class ToduDaemonClientError extends Error {
    readonly code: ToduDaemonClientErrorCode;
    readonly method: string;
    readonly details?: Record<string, unknown>;
    constructor(options: {
        code: ToduDaemonClientErrorCode;
        method: string;
        message: string;
        details?: Record<string, unknown>;
    });
}
export interface ToduProjectSummary {
    id: string;
    name: string;
    status: "active" | "done" | "cancelled";
    priority: TaskPriority;
    description: string | null;
    authorizedAssigneeActorIds: string[];
}
export interface ToduDaemonClient {
    listTasks(filter?: TaskFilter): Promise<TaskSummary[]>;
    getTask(taskId: TaskId): Promise<TaskDetail | null>;
    listActors(): Promise<ActorSummary[]>;
    createActor(input: {
        id: string;
        displayName: string;
    }): Promise<ActorSummary>;
    renameActor(input: {
        actorId: string;
        displayName: string;
    }): Promise<ActorSummary>;
    archiveActor(actorId: string): Promise<ActorSummary>;
    unarchiveActor(actorId: string): Promise<ActorSummary>;
    createTask(input: CreateTaskInput): Promise<TaskDetail>;
    updateTask(input: UpdateTaskInput): Promise<TaskDetail>;
    addTaskComment(input: AddTaskCommentInput): Promise<TaskComment>;
    listProjects(): Promise<ToduProjectSummary[]>;
    getProject(projectId: string): Promise<ToduProjectSummary | null>;
    createProject(input: CreateProjectInput): Promise<ToduProjectSummary>;
    updateProject(input: UpdateLocalProjectInput): Promise<ToduProjectSummary>;
    deleteProject(projectId: string): Promise<DeleteProjectResult>;
    listRecurring(filter?: RecurringFilter): Promise<RecurringTemplateSummary[]>;
    getRecurring(recurringId: string): Promise<RecurringTemplateDetail | null>;
    createRecurring(input: CreateRecurringInput): Promise<RecurringTemplateDetail>;
    updateRecurring(input: UpdateRecurringInput): Promise<RecurringTemplateDetail>;
    deleteRecurring(recurringId: string): Promise<DeleteRecurringResult>;
    listIntegrationBindings(filter?: IntegrationBindingFilter): Promise<IntegrationBinding[]>;
    getIntegrationBinding(bindingId: string): Promise<IntegrationBinding | null>;
    createIntegrationBinding(input: CreateIntegrationBindingInput): Promise<IntegrationBinding>;
    updateIntegrationBinding(input: UpdateIntegrationBindingInput): Promise<IntegrationBinding>;
    getIntegrationBindingStatus(bindingId: string): Promise<IntegrationBindingStatus | null>;
    listApprovals(filter?: ApprovalListFilter): Promise<ApprovalItem[]>;
    approveTaskDescription(taskId: string): Promise<ApprovalItem>;
    approveNoteContent(noteId: string): Promise<ApprovalItem>;
    deleteTask(taskId: TaskId): Promise<DeleteTaskResult>;
    moveTask(input: MoveTaskInput): Promise<MoveTaskResult>;
    listHabits(filter?: HabitFilter): Promise<HabitSummary[]>;
    getHabit(habitId: string): Promise<HabitDetail | null>;
    createHabit(input: CreateHabitInput): Promise<HabitDetail>;
    updateHabit(input: UpdateHabitInput): Promise<HabitDetail>;
    checkHabit(habitId: string): Promise<HabitCheckResult>;
    getHabitStreak(habitId: string): Promise<HabitStreak>;
    addHabitNote(input: AddHabitNoteInput): Promise<NoteSummary>;
    deleteHabit(habitId: string): Promise<DeleteHabitResult>;
    getNote(noteId: string): Promise<NoteSummary | null>;
    listNotes(filter?: NoteFilter): Promise<NoteSummary[]>;
    listTaskComments(taskId: TaskId): Promise<TaskComment[]>;
    on(eventName: ToduDaemonEventName, listener: ToduDaemonEventListener): Promise<ToduDaemonSubscription>;
}
export interface CreateToduDaemonClientOptions {
    connection: Pick<ToduDaemonConnection, "request" | "subscribeToEvents">;
}
declare const createToduDaemonClient: ({ connection, }: CreateToduDaemonClientOptions) => ToduDaemonClient;
declare const mapRecurringTemplateSummary: (template: ToduRecurringTemplate) => RecurringTemplateSummary;
declare const mapRecurringTemplateDetail: (template: ToduRecurringTemplate) => RecurringTemplateDetail;
declare const mapHabitSummary: (habit: ToduHabit) => HabitSummary;
declare const mapHabitDetail: (habit: ToduHabit) => HabitDetail;
declare const mapHabitCheckResult: (result: {
    habit: ToduHabit;
    date: string;
    completed: boolean;
    streak?: ToduHabitStreak;
}, habitId: string) => HabitCheckResult;
declare const mapCreateHabitInput: (input: CreateHabitInput) => Record<string, unknown>;
declare const mapUpdateHabitInput: (input: UpdateHabitInput) => Record<string, unknown>;
declare const mapHabitFilter: (filter: HabitFilter) => ToduHabitFilter;
declare const mapCreateRecurringInput: (input: CreateRecurringInput) => Record<string, unknown>;
declare const mapUpdateRecurringInput: (input: UpdateRecurringInput) => Record<string, unknown>;
declare const mapIntegrationBindingFilter: (filter: IntegrationBindingFilter) => ToduIntegrationBindingFilter;
declare const mapRecurringFilter: (filter: RecurringFilter) => ToduRecurringFilter;
declare const mapCreateIntegrationBindingInput: (input: CreateIntegrationBindingInput) => Record<string, unknown>;
declare const mapCreateProjectInput: (input: CreateProjectInput) => Record<string, unknown>;
declare const mapUpdateProjectInput: (input: UpdateLocalProjectInput) => Record<string, unknown>;
declare const mapDaemonErrorToClientError: (method: string, error: ToduDaemonConnectionError) => ToduDaemonClientError;
declare const toLocalTaskStatus: (status: ToduTaskStatus) => TaskStatus;
declare const toRemoteTaskStatus: (status: TaskStatus) => ToduTaskStatus;
declare const toRemoteProjectStatus: (status: ProjectSummary["status"]) => string;
export { createToduDaemonClient, mapCreateHabitInput, mapCreateIntegrationBindingInput, mapCreateProjectInput, mapCreateRecurringInput, mapDaemonErrorToClientError, mapHabitCheckResult, mapHabitDetail, mapHabitFilter, mapHabitSummary, mapIntegrationBindingFilter, mapRecurringFilter, mapRecurringTemplateDetail, mapRecurringTemplateSummary, mapUpdateHabitInput, mapUpdateProjectInput, mapUpdateRecurringInput, toLocalTaskStatus, toRemoteProjectStatus, toRemoteTaskStatus, };